fix(detector-aws): remove all deprecation warnings (#2642)

detectors/node/opentelemetry-resource-detector-aws/src/detectors/AwsBeanstalkDetectorSync.ts

@@ -25,15 +25,15 @@ import {
   ResourceDetectionConfig,
 } from '@opentelemetry/resources';
 import {
-  SEMRESATTRS_CLOUD_PROVIDER,
-  SEMRESATTRS_CLOUD_PLATFORM,
-  SEMRESATTRS_SERVICE_NAME,
-  SEMRESATTRS_SERVICE_NAMESPACE,
-  SEMRESATTRS_SERVICE_VERSION,
-  SEMRESATTRS_SERVICE_INSTANCE_ID,
-  CLOUDPROVIDERVALUES_AWS,
-  CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK,
-} from '@opentelemetry/semantic-conventions';
+  ATTR_CLOUD_PROVIDER,
+  ATTR_CLOUD_PLATFORM,
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_NAMESPACE,
+  ATTR_SERVICE_VERSION,
+  ATTR_SERVICE_INSTANCE_ID,
+  CLOUD_PROVIDER_VALUE_AWS,
+  CLOUD_PLATFORM_VALUE_AWS_ELASTIC_BEANSTALK,
+} from '@opentelemetry/semantic-conventions/incubating';
 import * as fs from 'fs';
 import * as util from 'util';
 
@@ -95,12 +95,12 @@ export class AwsBeanstalkDetectorSync implements DetectorSync {
       const parsedData = JSON.parse(rawData);
 
       return {
-        [SEMRESATTRS_CLOUD_PROVIDER]: CLOUDPROVIDERVALUES_AWS,
-        [SEMRESATTRS_CLOUD_PLATFORM]: CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK,
-        [SEMRESATTRS_SERVICE_NAME]: CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK,
-        [SEMRESATTRS_SERVICE_NAMESPACE]: parsedData.environment_name,
-        [SEMRESATTRS_SERVICE_VERSION]: parsedData.version_label,
-        [SEMRESATTRS_SERVICE_INSTANCE_ID]: parsedData.deployment_id,
+        [ATTR_CLOUD_PROVIDER]: CLOUD_PROVIDER_VALUE_AWS,
+        [ATTR_CLOUD_PLATFORM]: CLOUD_PLATFORM_VALUE_AWS_ELASTIC_BEANSTALK,
+        [ATTR_SERVICE_NAME]: CLOUD_PLATFORM_VALUE_AWS_ELASTIC_BEANSTALK,
+        [ATTR_SERVICE_NAMESPACE]: parsedData.environment_name,
+        [ATTR_SERVICE_VERSION]: parsedData.version_label,
+        [ATTR_SERVICE_INSTANCE_ID]: parsedData.deployment_id,
       };
     } catch (e: any) {
       diag.debug(`AwsBeanstalkDetectorSync failed: ${e.message}`);

detectors/node/opentelemetry-resource-detector-aws/src/detectors/AwsEc2DetectorSync.ts

@@ -24,17 +24,17 @@ import {
   ResourceDetectionConfig,
 } from '@opentelemetry/resources';
 import {
-  SEMRESATTRS_CLOUD_PROVIDER,
-  SEMRESATTRS_CLOUD_PLATFORM,
-  SEMRESATTRS_CLOUD_REGION,
-  SEMRESATTRS_CLOUD_ACCOUNT_ID,
-  SEMRESATTRS_CLOUD_AVAILABILITY_ZONE,
-  SEMRESATTRS_HOST_ID,
-  SEMRESATTRS_HOST_TYPE,
-  SEMRESATTRS_HOST_NAME,
-  CLOUDPROVIDERVALUES_AWS,
-  CLOUDPLATFORMVALUES_AWS_EC2,
-} from '@opentelemetry/semantic-conventions';
+  ATTR_CLOUD_PROVIDER,
+  ATTR_CLOUD_PLATFORM,
+  ATTR_CLOUD_REGION,
+  ATTR_CLOUD_ACCOUNT_ID,
+  ATTR_CLOUD_AVAILABILITY_ZONE,
+  ATTR_HOST_ID,
+  ATTR_HOST_TYPE,
+  ATTR_HOST_NAME,
+  CLOUD_PROVIDER_VALUE_AWS,
+  CLOUD_PLATFORM_VALUE_AWS_EC2,
+} from '@opentelemetry/semantic-conventions/incubating';
 import * as http from 'http';
 
 /**
@@ -79,14 +79,14 @@ class AwsEc2DetectorSync implements DetectorSync {
       const hostname = await this._fetchHost(token);
 
       return {
-        [SEMRESATTRS_CLOUD_PROVIDER]: CLOUDPROVIDERVALUES_AWS,
-        [SEMRESATTRS_CLOUD_PLATFORM]: CLOUDPLATFORMVALUES_AWS_EC2,
-        [SEMRESATTRS_CLOUD_ACCOUNT_ID]: accountId,
-        [SEMRESATTRS_CLOUD_REGION]: region,
-        [SEMRESATTRS_CLOUD_AVAILABILITY_ZONE]: availabilityZone,
-        [SEMRESATTRS_HOST_ID]: instanceId,
-        [SEMRESATTRS_HOST_TYPE]: instanceType,
-        [SEMRESATTRS_HOST_NAME]: hostname,
+        [ATTR_CLOUD_PROVIDER]: CLOUD_PROVIDER_VALUE_AWS,
+        [ATTR_CLOUD_PLATFORM]: CLOUD_PLATFORM_VALUE_AWS_EC2,
+        [ATTR_CLOUD_ACCOUNT_ID]: accountId,
+        [ATTR_CLOUD_REGION]: region,
+        [ATTR_CLOUD_AVAILABILITY_ZONE]: availabilityZone,
+        [ATTR_HOST_ID]: instanceId,
+        [ATTR_HOST_TYPE]: instanceType,
+        [ATTR_HOST_NAME]: hostname,
       };
     } catch {
       return {};

detectors/node/opentelemetry-resource-detector-aws/src/detectors/AwsEcsDetectorSync.ts

@@ -23,26 +23,26 @@ import {
   ResourceAttributes,
 } from '@opentelemetry/resources';
 import {
-  SEMRESATTRS_CLOUD_PROVIDER,
-  SEMRESATTRS_CLOUD_PLATFORM,
-  SEMRESATTRS_CONTAINER_ID,
-  SEMRESATTRS_CONTAINER_NAME,
-  SEMRESATTRS_AWS_ECS_CONTAINER_ARN,
-  SEMRESATTRS_AWS_ECS_CLUSTER_ARN,
-  SEMRESATTRS_AWS_ECS_LAUNCHTYPE,
-  SEMRESATTRS_AWS_ECS_TASK_ARN,
-  SEMRESATTRS_AWS_ECS_TASK_FAMILY,
-  SEMRESATTRS_AWS_ECS_TASK_REVISION,
-  SEMRESATTRS_CLOUD_ACCOUNT_ID,
-  SEMRESATTRS_CLOUD_REGION,
-  SEMRESATTRS_CLOUD_AVAILABILITY_ZONE,
-  SEMRESATTRS_AWS_LOG_GROUP_NAMES,
-  SEMRESATTRS_AWS_LOG_GROUP_ARNS,
-  SEMRESATTRS_AWS_LOG_STREAM_NAMES,
-  SEMRESATTRS_AWS_LOG_STREAM_ARNS,
-  CLOUDPROVIDERVALUES_AWS,
-  CLOUDPLATFORMVALUES_AWS_ECS,
-} from '@opentelemetry/semantic-conventions';
+  ATTR_CLOUD_PROVIDER,
+  ATTR_CLOUD_PLATFORM,
+  ATTR_CONTAINER_ID,
+  ATTR_CONTAINER_NAME,
+  ATTR_AWS_ECS_CONTAINER_ARN,
+  ATTR_AWS_ECS_CLUSTER_ARN,
+  ATTR_AWS_ECS_LAUNCHTYPE,
+  ATTR_AWS_ECS_TASK_ARN,
+  ATTR_AWS_ECS_TASK_FAMILY,
+  ATTR_AWS_ECS_TASK_REVISION,
+  ATTR_CLOUD_ACCOUNT_ID,
+  ATTR_CLOUD_REGION,
+  ATTR_CLOUD_AVAILABILITY_ZONE,
+  ATTR_AWS_LOG_GROUP_NAMES,
+  ATTR_AWS_LOG_GROUP_ARNS,
+  ATTR_AWS_LOG_STREAM_NAMES,
+  ATTR_AWS_LOG_STREAM_ARNS,
+  CLOUD_PROVIDER_VALUE_AWS,
+  CLOUD_PLATFORM_VALUE_AWS_ECS,
+} from '@opentelemetry/semantic-conventions/incubating';
 // Patch until the OpenTelemetry SDK is updated to ship this attribute
 import { SemanticResourceAttributes as AdditionalSemanticResourceAttributes } from './SemanticResourceAttributes';
 import * as http from 'http';
@@ -86,8 +86,8 @@ export class AwsEcsDetectorSync implements DetectorSync {
 
     try {
       let resource = new Resource({
-        [SEMRESATTRS_CLOUD_PROVIDER]: CLOUDPROVIDERVALUES_AWS,
-        [SEMRESATTRS_CLOUD_PLATFORM]: CLOUDPLATFORMVALUES_AWS_ECS,
+        [ATTR_CLOUD_PROVIDER]: CLOUD_PROVIDER_VALUE_AWS,
+        [ATTR_CLOUD_PLATFORM]: CLOUD_PLATFORM_VALUE_AWS_ECS,
       }).merge(await AwsEcsDetectorSync._getContainerIdAndHostnameResource());
 
       const metadataUrl = getEnv().ECS_CONTAINER_METADATA_URI_V4;
@@ -146,8 +146,8 @@ export class AwsEcsDetectorSync implements DetectorSync {
 
     if (hostName || containerId) {
       return new Resource({
-        [SEMRESATTRS_CONTAINER_NAME]: hostName || '',
-        [SEMRESATTRS_CONTAINER_ID]: containerId || '',
+        [ATTR_CONTAINER_NAME]: hostName || '',
+        [ATTR_CONTAINER_ID]: containerId || '',
       });
     }
 
@@ -177,21 +177,21 @@ export class AwsEcsDetectorSync implements DetectorSync {
 
     // https://github.com/open-telemetry/semantic-conventions/blob/main/semantic_conventions/resource/cloud_provider/aws/ecs.yaml
     const attributes: ResourceAttributes = {
-      [SEMRESATTRS_AWS_ECS_CONTAINER_ARN]: containerArn,
-      [SEMRESATTRS_AWS_ECS_CLUSTER_ARN]: clusterArn,
-      [SEMRESATTRS_AWS_ECS_LAUNCHTYPE]: launchType?.toLowerCase(),
-      [SEMRESATTRS_AWS_ECS_TASK_ARN]: taskArn,
-      [SEMRESATTRS_AWS_ECS_TASK_FAMILY]: taskMetadata['Family'],
-      [SEMRESATTRS_AWS_ECS_TASK_REVISION]: taskMetadata['Revision'],
-
-      [SEMRESATTRS_CLOUD_ACCOUNT_ID]: accountId,
-      [SEMRESATTRS_CLOUD_REGION]: region,
+      [ATTR_AWS_ECS_CONTAINER_ARN]: containerArn,
+      [ATTR_AWS_ECS_CLUSTER_ARN]: clusterArn,
+      [ATTR_AWS_ECS_LAUNCHTYPE]: launchType?.toLowerCase(),
+      [ATTR_AWS_ECS_TASK_ARN]: taskArn,
+      [ATTR_AWS_ECS_TASK_FAMILY]: taskMetadata['Family'],
+      [ATTR_AWS_ECS_TASK_REVISION]: taskMetadata['Revision'],
+
+      [ATTR_CLOUD_ACCOUNT_ID]: accountId,
+      [ATTR_CLOUD_REGION]: region,
       [AdditionalSemanticResourceAttributes.CLOUD_RESOURCE_ID]: containerArn,
     };
 
     // The availability zone is not available in all Fargate runtimes
     if (availabilityZone) {
-      attributes[SEMRESATTRS_CLOUD_AVAILABILITY_ZONE] = availabilityZone;
+      attributes[ATTR_CLOUD_AVAILABILITY_ZONE] = availabilityZone;
     }
 
     return new Resource(attributes);
@@ -222,10 +222,10 @@ export class AwsEcsDetectorSync implements DetectorSync {
     const logsStreamArn = `arn:aws:logs:${logsRegion}:${awsAccount}:log-group:${logsGroupName}:log-stream:${logsStreamName}`;
 
     return new Resource({
-      [SEMRESATTRS_AWS_LOG_GROUP_NAMES]: [logsGroupName],
-      [SEMRESATTRS_AWS_LOG_GROUP_ARNS]: [logsGroupArn],
-      [SEMRESATTRS_AWS_LOG_STREAM_NAMES]: [logsStreamName],
-      [SEMRESATTRS_AWS_LOG_STREAM_ARNS]: [logsStreamArn],
+      [ATTR_AWS_LOG_GROUP_NAMES]: [logsGroupName],
+      [ATTR_AWS_LOG_GROUP_ARNS]: [logsGroupArn],
+      [ATTR_AWS_LOG_STREAM_NAMES]: [logsStreamName],
+      [ATTR_AWS_LOG_STREAM_ARNS]: [logsStreamArn],
     });
   }
 

detectors/node/opentelemetry-resource-detector-aws/src/detectors/AwsEksDetectorSync.ts

@@ -24,13 +24,13 @@ import {
   ResourceDetectionConfig,
 } from '@opentelemetry/resources';
 import {
-  SEMRESATTRS_CLOUD_PROVIDER,
-  SEMRESATTRS_CLOUD_PLATFORM,
-  SEMRESATTRS_K8S_CLUSTER_NAME,
-  SEMRESATTRS_CONTAINER_ID,
-  CLOUDPROVIDERVALUES_AWS,
-  CLOUDPLATFORMVALUES_AWS_EKS,
-} from '@opentelemetry/semantic-conventions';
+  ATTR_CLOUD_PROVIDER,
+  ATTR_CLOUD_PLATFORM,
+  ATTR_K8S_CLUSTER_NAME,
+  ATTR_CONTAINER_ID,
+  CLOUD_PROVIDER_VALUE_AWS,
+  CLOUD_PLATFORM_VALUE_AWS_EKS,
+} from '@opentelemetry/semantic-conventions/incubating';
 import * as https from 'https';
 import * as fs from 'fs';
 import * as util from 'util';
@@ -94,10 +94,10 @@ export class AwsEksDetectorSync implements DetectorSync {
       return !containerId && !clusterName
         ? {}
         : {
-            [SEMRESATTRS_CLOUD_PROVIDER]: CLOUDPROVIDERVALUES_AWS,
-            [SEMRESATTRS_CLOUD_PLATFORM]: CLOUDPLATFORMVALUES_AWS_EKS,
-            [SEMRESATTRS_K8S_CLUSTER_NAME]: clusterName || '',
-            [SEMRESATTRS_CONTAINER_ID]: containerId || '',
+            [ATTR_CLOUD_PROVIDER]: CLOUD_PROVIDER_VALUE_AWS,
+            [ATTR_CLOUD_PLATFORM]: CLOUD_PLATFORM_VALUE_AWS_EKS,
+            [ATTR_K8S_CLUSTER_NAME]: clusterName || '',
+            [ATTR_CONTAINER_ID]: containerId || '',
           };
     } catch (e) {
       diag.debug('Process is not running on K8S', e);

detectors/node/opentelemetry-resource-detector-aws/src/detectors/AwsLambdaDetectorSync.ts

@@ -22,14 +22,14 @@ import {
   ResourceDetectionConfig,
 } from '@opentelemetry/resources';
 import {
-  SEMRESATTRS_CLOUD_PROVIDER,
-  SEMRESATTRS_CLOUD_PLATFORM,
-  SEMRESATTRS_CLOUD_REGION,
-  SEMRESATTRS_FAAS_VERSION,
-  SEMRESATTRS_FAAS_NAME,
-  CLOUDPROVIDERVALUES_AWS,
-  CLOUDPLATFORMVALUES_AWS_LAMBDA,
-} from '@opentelemetry/semantic-conventions';
+  ATTR_CLOUD_PROVIDER,
+  ATTR_CLOUD_PLATFORM,
+  ATTR_CLOUD_REGION,
+  ATTR_FAAS_VERSION,
+  ATTR_FAAS_NAME,
+  CLOUD_PROVIDER_VALUE_AWS,
+  CLOUD_PLATFORM_VALUE_AWS_LAMBDA,
+} from '@opentelemetry/semantic-conventions/incubating';
 
 /**
  * The AwsLambdaDetector can be used to detect if a process is running in AWS Lambda
@@ -47,18 +47,18 @@ export class AwsLambdaDetectorSync implements DetectorSync {
     const region = process.env.AWS_REGION;
 
     const attributes: ResourceAttributes = {
-      [SEMRESATTRS_CLOUD_PROVIDER]: String(CLOUDPROVIDERVALUES_AWS),
-      [SEMRESATTRS_CLOUD_PLATFORM]: String(CLOUDPLATFORMVALUES_AWS_LAMBDA),
+      [ATTR_CLOUD_PROVIDER]: String(CLOUD_PROVIDER_VALUE_AWS),
+      [ATTR_CLOUD_PLATFORM]: String(CLOUD_PLATFORM_VALUE_AWS_LAMBDA),
     };
     if (region) {
-      attributes[SEMRESATTRS_CLOUD_REGION] = region;
+      attributes[ATTR_CLOUD_REGION] = region;
     }
 
     if (functionName) {
-      attributes[SEMRESATTRS_FAAS_NAME] = functionName;
+      attributes[ATTR_FAAS_NAME] = functionName;
     }
     if (functionVersion) {
-      attributes[SEMRESATTRS_FAAS_VERSION] = functionVersion;
+      attributes[ATTR_FAAS_VERSION] = functionVersion;
     }
 
     return new Resource(attributes);