chore(resources): update semconv usage to modern ATTR_ export names

packages/opentelemetry-resources/README.md

@@ -16,16 +16,18 @@ npm install --save @opentelemetry/resources
 ## Usage
 
 ```typescript
-import { SEMRESATTRS_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+import {
+    ATTR_SERVICE_NAME,
+    ATTR_SERVICE_VERSION,
+} from '@opentelemetry/semantic-conventions';
 import { Resource } from '@opentelemetry/resources';
 
 const resource = new Resource({
-    [SEMRESATTRS_SERVICE_NAME]: 'api-service',
+    [ATTR_SERVICE_NAME]: 'api-service',
 });
 
 const anotherResource = new Resource({
-    'service.version': '2.0.0',
-    'service.group': 'instrumentation-group'
+    [ATTR_SERVICE_VERSION]: '2.0.0'
 });
 const mergedResource = resource.merge(anotherResource);
 ```

packages/opentelemetry-resources/src/Resource.ts

@@ -16,10 +16,10 @@
 
 import { diag } from '@opentelemetry/api';
 import {
-  SEMRESATTRS_SERVICE_NAME,
-  SEMRESATTRS_TELEMETRY_SDK_LANGUAGE,
-  SEMRESATTRS_TELEMETRY_SDK_NAME,
-  SEMRESATTRS_TELEMETRY_SDK_VERSION,
+  ATTR_SERVICE_NAME,
+  ATTR_TELEMETRY_SDK_LANGUAGE,
+  ATTR_TELEMETRY_SDK_NAME,
+  ATTR_TELEMETRY_SDK_VERSION,
 } from '@opentelemetry/semantic-conventions';
 import { SDK_INFO } from '@opentelemetry/core';
 import { ResourceAttributes } from './types';
@@ -56,13 +56,10 @@ export class Resource implements IResource {
    */
   static default(): IResource {
     return new Resource({
-      [SEMRESATTRS_SERVICE_NAME]: defaultServiceName(),
-      [SEMRESATTRS_TELEMETRY_SDK_LANGUAGE]:
-        SDK_INFO[SEMRESATTRS_TELEMETRY_SDK_LANGUAGE],
-      [SEMRESATTRS_TELEMETRY_SDK_NAME]:
-        SDK_INFO[SEMRESATTRS_TELEMETRY_SDK_NAME],
-      [SEMRESATTRS_TELEMETRY_SDK_VERSION]:
-        SDK_INFO[SEMRESATTRS_TELEMETRY_SDK_VERSION],
+      [ATTR_SERVICE_NAME]: defaultServiceName(),
+      [ATTR_TELEMETRY_SDK_LANGUAGE]: SDK_INFO[ATTR_TELEMETRY_SDK_LANGUAGE],
+      [ATTR_TELEMETRY_SDK_NAME]: SDK_INFO[ATTR_TELEMETRY_SDK_NAME],
+      [ATTR_TELEMETRY_SDK_VERSION]: SDK_INFO[ATTR_TELEMETRY_SDK_VERSION],
     });
   }
 

packages/opentelemetry-resources/src/detectors/BrowserDetectorSync.ts

@@ -15,10 +15,10 @@
  */
 
 import {
-  SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION,
-  SEMRESATTRS_PROCESS_RUNTIME_NAME,
-  SEMRESATTRS_PROCESS_RUNTIME_VERSION,
-} from '@opentelemetry/semantic-conventions';
+  ATTR_PROCESS_RUNTIME_DESCRIPTION,
+  ATTR_PROCESS_RUNTIME_NAME,
+  ATTR_PROCESS_RUNTIME_VERSION,
+} from '@opentelemetry/semantic-conventions/incubating';
 import { DetectorSync, ResourceAttributes } from '../types';
 import { diag } from '@opentelemetry/api';
 import { ResourceDetectionConfig } from '../config';
@@ -40,9 +40,9 @@
       return Resource.empty();
     }
     const browserResource: ResourceAttributes = {
-      [SEMRESATTRS_PROCESS_RUNTIME_NAME]: 'browser',
-      [SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION]: 'Web Browser',
-      [SEMRESATTRS_PROCESS_RUNTIME_VERSION]: navigator.userAgent,
+      [ATTR_PROCESS_RUNTIME_NAME]: 'browser',
+      [ATTR_PROCESS_RUNTIME_DESCRIPTION]: 'Web Browser',
+      [ATTR_PROCESS_RUNTIME_VERSION]: navigator.userAgent,
     };
     return this._getResourceAttributes(browserResource, config);
   }
@@ -57,7 +57,7 @@
     browserResource: ResourceAttributes,
     _config?: ResourceDetectionConfig
   ) {
-    if (browserResource[SEMRESATTRS_PROCESS_RUNTIME_VERSION] === '') {
+    if (browserResource[ATTR_PROCESS_RUNTIME_VERSION] === '') {
       diag.debug(
         'BrowserDetector failed: Unable to find required browser resources. '
       );

packages/opentelemetry-resources/src/detectors/EnvDetectorSync.ts

@@ -16,7 +16,7 @@
 
 import { diag } from '@opentelemetry/api';
 import { getEnv } from '@opentelemetry/core';
-import { SEMRESATTRS_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
 import { Resource } from '../Resource';
 import { DetectorSync, ResourceAttributes } from '../types';
 import { ResourceDetectionConfig } from '../config';
@@ -70,7 +70,7 @@
     }
 
     if (serviceName) {
-      attributes[SEMRESATTRS_SERVICE_NAME] = serviceName;
+      attributes[ATTR_SERVICE_NAME] = serviceName;
     }
 
     return new Resource(attributes);

packages/opentelemetry-resources/src/detectors/platform/node/HostDetectorSync.ts

@@ -15,10 +15,10 @@
  */
 
 import {
-  SEMRESATTRS_HOST_ARCH,
-  SEMRESATTRS_HOST_ID,
-  SEMRESATTRS_HOST_NAME,
-} from '@opentelemetry/semantic-conventions';
+  ATTR_HOST_ARCH,
+  ATTR_HOST_ID,
+  ATTR_HOST_NAME,
+} from '@opentelemetry/semantic-conventions/incubating';
 import { Resource } from '../../../Resource';
 import { DetectorSync, ResourceAttributes } from '../../../types';
 import { ResourceDetectionConfig } from '../../../config';
@@ -33,8 +33,8 @@ import { getMachineId } from './machine-id/getMachineId';
 class HostDetectorSync implements DetectorSync {
   detect(_config?: ResourceDetectionConfig): Resource {
     const attributes: ResourceAttributes = {
-      [SEMRESATTRS_HOST_NAME]: hostname(),
-      [SEMRESATTRS_HOST_ARCH]: normalizeArch(arch()),
+      [ATTR_HOST_NAME]: hostname(),
+      [ATTR_HOST_ARCH]: normalizeArch(arch()),
     };
 
     return new Resource(attributes, this._getAsyncAttributes());
@@ -44,7 +44,7 @@ class HostDetectorSync implements DetectorSync {
     return getMachineId().then(machineId => {
       const attributes: ResourceAttributes = {};
       if (machineId) {
-        attributes[SEMRESATTRS_HOST_ID] = machineId;
+        attributes[ATTR_HOST_ID] = machineId;
       }
       return attributes;
     });

packages/opentelemetry-resources/src/detectors/platform/node/OSDetectorSync.ts

@@ -15,9 +15,9 @@
  */
 
 import {
-  SEMRESATTRS_OS_TYPE,
-  SEMRESATTRS_OS_VERSION,
-} from '@opentelemetry/semantic-conventions';
+  ATTR_OS_TYPE,
+  ATTR_OS_VERSION,
+} from '@opentelemetry/semantic-conventions/incubating';
 import { Resource } from '../../../Resource';
 import { DetectorSync, ResourceAttributes } from '../../../types';
 import { ResourceDetectionConfig } from '../../../config';
@@ -31,8 +31,8 @@ import { normalizeType } from './utils';
 class OSDetectorSync implements DetectorSync {
   detect(_config?: ResourceDetectionConfig): Resource {
     const attributes: ResourceAttributes = {
-      [SEMRESATTRS_OS_TYPE]: normalizeType(platform()),
-      [SEMRESATTRS_OS_VERSION]: release(),
+      [ATTR_OS_TYPE]: normalizeType(platform()),
+      [ATTR_OS_VERSION]: release(),
     };
     return new Resource(attributes);
   }

packages/opentelemetry-resources/src/detectors/platform/node/ProcessDetectorSync.ts

@@ -16,16 +16,16 @@
 
 import { diag } from '@opentelemetry/api';
 import {
-  SEMRESATTRS_PROCESS_COMMAND,
-  SEMRESATTRS_PROCESS_COMMAND_ARGS,
-  SEMRESATTRS_PROCESS_EXECUTABLE_NAME,
-  SEMRESATTRS_PROCESS_EXECUTABLE_PATH,
-  SEMRESATTRS_PROCESS_OWNER,
-  SEMRESATTRS_PROCESS_PID,
-  SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION,
-  SEMRESATTRS_PROCESS_RUNTIME_NAME,
-  SEMRESATTRS_PROCESS_RUNTIME_VERSION,
-} from '@opentelemetry/semantic-conventions';
+  ATTR_PROCESS_COMMAND,
+  ATTR_PROCESS_COMMAND_ARGS,
+  ATTR_PROCESS_EXECUTABLE_NAME,
+  ATTR_PROCESS_EXECUTABLE_PATH,
+  ATTR_PROCESS_OWNER,
+  ATTR_PROCESS_PID,
+  ATTR_PROCESS_RUNTIME_DESCRIPTION,
+  ATTR_PROCESS_RUNTIME_NAME,
+  ATTR_PROCESS_RUNTIME_VERSION,
+} from '@opentelemetry/semantic-conventions/incubating';
 import { Resource } from '../../../Resource';
 import { DetectorSync, ResourceAttributes } from '../../../types';
 import { ResourceDetectionConfig } from '../../../config';
@@ -39,26 +39,26 @@ import * as os from 'os';
 class ProcessDetectorSync implements DetectorSync {
   detect(_config?: ResourceDetectionConfig): IResource {
     const attributes: ResourceAttributes = {
-      [SEMRESATTRS_PROCESS_PID]: process.pid,
-      [SEMRESATTRS_PROCESS_EXECUTABLE_NAME]: process.title,
-      [SEMRESATTRS_PROCESS_EXECUTABLE_PATH]: process.execPath,
-      [SEMRESATTRS_PROCESS_COMMAND_ARGS]: [
+      [ATTR_PROCESS_PID]: process.pid,
+      [ATTR_PROCESS_EXECUTABLE_NAME]: process.title,
+      [ATTR_PROCESS_EXECUTABLE_PATH]: process.execPath,
+      [ATTR_PROCESS_COMMAND_ARGS]: [
         process.argv[0],
         ...process.execArgv,
         ...process.argv.slice(1),
       ],
-      [SEMRESATTRS_PROCESS_RUNTIME_VERSION]: process.versions.node,
-      [SEMRESATTRS_PROCESS_RUNTIME_NAME]: 'nodejs',
-      [SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION]: 'Node.js',
+      [ATTR_PROCESS_RUNTIME_VERSION]: process.versions.node,
+      [ATTR_PROCESS_RUNTIME_NAME]: 'nodejs',
+      [ATTR_PROCESS_RUNTIME_DESCRIPTION]: 'Node.js',
     };
 
     if (process.argv.length > 1) {
-      attributes[SEMRESATTRS_PROCESS_COMMAND] = process.argv[1];
+      attributes[ATTR_PROCESS_COMMAND] = process.argv[1];
     }
 
     try {
       const userInfo = os.userInfo();
-      attributes[SEMRESATTRS_PROCESS_OWNER] = userInfo.username;
+      attributes[ATTR_PROCESS_OWNER] = userInfo.username;
     } catch (e) {
       diag.debug(`error obtaining process owner: ${e}`);
     }

packages/opentelemetry-resources/src/detectors/platform/node/ServiceInstanceIdDetectorSync.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { SEMRESATTRS_SERVICE_INSTANCE_ID } from '@opentelemetry/semantic-conventions';
+import { ATTR_SERVICE_INSTANCE_ID } from '@opentelemetry/semantic-conventions/incubating';
 import { Resource } from '../../../Resource';
 import { DetectorSync, ResourceAttributes } from '../../../types';
 import { ResourceDetectionConfig } from '../../../config';
@@ -26,7 +26,7 @@ import { randomUUID } from 'crypto';
 class ServiceInstanceIdDetectorSync implements DetectorSync {
   detect(_config?: ResourceDetectionConfig): Resource {
     const attributes: ResourceAttributes = {
-      [SEMRESATTRS_SERVICE_INSTANCE_ID]: randomUUID(),
+      [ATTR_SERVICE_INSTANCE_ID]: randomUUID(),
     };
 
     return new Resource(attributes);

packages/opentelemetry-resources/test/Resource.test.ts

@@ -19,10 +19,10 @@ import * as assert from 'assert';
 import { SDK_INFO } from '@opentelemetry/core';
 import { Resource, ResourceAttributes } from '../src';
 import {
-  SEMRESATTRS_SERVICE_NAME,
-  SEMRESATTRS_TELEMETRY_SDK_LANGUAGE,
-  SEMRESATTRS_TELEMETRY_SDK_NAME,
-  SEMRESATTRS_TELEMETRY_SDK_VERSION,
+  ATTR_SERVICE_NAME,
+  ATTR_TELEMETRY_SDK_LANGUAGE,
+  ATTR_TELEMETRY_SDK_NAME,
+  ATTR_TELEMETRY_SDK_VERSION,
 } from '@opentelemetry/semantic-conventions';
 import { describeBrowser, describeNode } from './util';
 import { diag } from '@opentelemetry/api';
@@ -285,19 +285,19 @@ describe('Resource', () => {
     it('should return a default resource', () => {
       const resource = Resource.default();
       assert.strictEqual(
-        resource.attributes[SEMRESATTRS_TELEMETRY_SDK_NAME],
-        SDK_INFO[SEMRESATTRS_TELEMETRY_SDK_NAME]
+        resource.attributes[ATTR_TELEMETRY_SDK_NAME],
+        SDK_INFO[ATTR_TELEMETRY_SDK_NAME]
       );
       assert.strictEqual(
-        resource.attributes[SEMRESATTRS_TELEMETRY_SDK_LANGUAGE],
-        SDK_INFO[SEMRESATTRS_TELEMETRY_SDK_LANGUAGE]
+        resource.attributes[ATTR_TELEMETRY_SDK_LANGUAGE],
+        SDK_INFO[ATTR_TELEMETRY_SDK_LANGUAGE]
       );
       assert.strictEqual(
-        resource.attributes[SEMRESATTRS_TELEMETRY_SDK_VERSION],
-        SDK_INFO[SEMRESATTRS_TELEMETRY_SDK_VERSION]
+        resource.attributes[ATTR_TELEMETRY_SDK_VERSION],
+        SDK_INFO[ATTR_TELEMETRY_SDK_VERSION]
       );
       assert.strictEqual(
-        resource.attributes[SEMRESATTRS_SERVICE_NAME],
+        resource.attributes[ATTR_SERVICE_NAME],
         `unknown_service:${process.argv0}`
       );
     });
@@ -307,19 +307,19 @@ describe('Resource', () => {
     it('should return a default resource', () => {
       const resource = Resource.default();
       assert.strictEqual(
-        resource.attributes[SEMRESATTRS_TELEMETRY_SDK_NAME],
-        SDK_INFO[SEMRESATTRS_TELEMETRY_SDK_NAME]
+        resource.attributes[ATTR_TELEMETRY_SDK_NAME],
+        SDK_INFO[ATTR_TELEMETRY_SDK_NAME]
       );
       assert.strictEqual(
-        resource.attributes[SEMRESATTRS_TELEMETRY_SDK_LANGUAGE],
-        SDK_INFO[SEMRESATTRS_TELEMETRY_SDK_LANGUAGE]
+        resource.attributes[ATTR_TELEMETRY_SDK_LANGUAGE],
+        SDK_INFO[ATTR_TELEMETRY_SDK_LANGUAGE]
       );
       assert.strictEqual(
-        resource.attributes[SEMRESATTRS_TELEMETRY_SDK_VERSION],
-        SDK_INFO[SEMRESATTRS_TELEMETRY_SDK_VERSION]
+        resource.attributes[ATTR_TELEMETRY_SDK_VERSION],
+        SDK_INFO[ATTR_TELEMETRY_SDK_VERSION]
       );
       assert.strictEqual(
-        resource.attributes[SEMRESATTRS_SERVICE_NAME],
+        resource.attributes[ATTR_SERVICE_NAME],
         'unknown_service'
       );
     });

packages/opentelemetry-resources/test/detectors/node/HostDetector.test.ts

@@ -17,10 +17,10 @@
 import * as sinon from 'sinon';
 import * as assert from 'assert';
 import {
-  SEMRESATTRS_HOST_ARCH,
-  SEMRESATTRS_HOST_ID,
-  SEMRESATTRS_HOST_NAME,
-} from '@opentelemetry/semantic-conventions';
+  ATTR_HOST_ARCH,
+  ATTR_HOST_ID,
+  ATTR_HOST_NAME,
+} from '@opentelemetry/semantic-conventions/incubating';
 import { describeNode } from '../../util';
 import { hostDetector, IResource } from '../../../src';
 
@@ -43,14 +43,11 @@ describeNode('hostDetector() on Node.js', () => {
     await resource.waitForAsyncAttributes?.();
 
     assert.strictEqual(
-      resource.attributes[SEMRESATTRS_HOST_NAME],
+      resource.attributes[ATTR_HOST_NAME],
       'opentelemetry-test'
     );
-    assert.strictEqual(resource.attributes[SEMRESATTRS_HOST_ARCH], 'amd64');
-    assert.strictEqual(
-      resource.attributes[SEMRESATTRS_HOST_ID],
-      expectedHostId
-    );
+    assert.strictEqual(resource.attributes[ATTR_HOST_ARCH], 'amd64');
+    assert.strictEqual(resource.attributes[ATTR_HOST_ID], expectedHostId);
   });
 
   it('should pass through arch string if unknown', async () => {
@@ -61,7 +58,7 @@ describeNode('hostDetector() on Node.js', () => {
     const resource: IResource = await hostDetector.detect();
 
     assert.strictEqual(
-      resource.attributes[SEMRESATTRS_HOST_ARCH],
+      resource.attributes[ATTR_HOST_ARCH],
       'some-unknown-arch'
     );
   });
@@ -78,10 +75,10 @@ describeNode('hostDetector() on Node.js', () => {
     await resource.waitForAsyncAttributes?.();
 
     assert.strictEqual(
-      resource.attributes[SEMRESATTRS_HOST_NAME],
+      resource.attributes[ATTR_HOST_NAME],
       'opentelemetry-test'
     );
-    assert.strictEqual(resource.attributes[SEMRESATTRS_HOST_ARCH], 'amd64');
-    assert.strictEqual(false, SEMRESATTRS_HOST_ID in resource.attributes);
+    assert.strictEqual(resource.attributes[ATTR_HOST_ARCH], 'amd64');
+    assert.strictEqual(false, ATTR_HOST_ID in resource.attributes);
   });
 });