Merge branch 'aws-observability:main' into main

Author: mxiamxia

.github/workflows/application-signals-e2e-test.yml

@@ -0,0 +1,77 @@
+## Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+## SPDX-License-Identifier: Apache-2.0
+
+# This is a reusable workflow for running the E2E test for Application Signals.
+# It is meant to be called from another workflow.
+# Read more about reusable workflows: https://docs.github.com/en/actions/using-workflows/reusing-workflows#overview
+name: E2E Testing
+on:
+  workflow_call:
+    inputs:
+      staging-instrumentation-name:
+        required: true
+        type: string
+      adot-image-name:
+        required: true
+        type: string
+
+permissions:
+  id-token: write
+  contents: read
+
+concurrency:
+  group: '${{ github.workflow }} @ ${{ inputs.aws-region }}'
+  cancel-in-progress: false
+
+
+jobs:
+  upload-main-build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Configure AWS Credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          role-to-assume: arn:aws:iam::637423224110:role/${{ secrets.STAGING_ARTIFACTS_ACCESS_ROLE_NAME }}
+          aws-region: us-east-1
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: ${{ inputs.staging-instrumentation-name }}
+
+      - name: Upload main-build instrumentation to S3
+        run: aws s3 cp ${{ inputs.staging-instrumentation-name }} s3://adot-autoinstrumentation-node-staging/${{ inputs.staging-instrumentation-name }}
+
+  ec2-default:
+    needs: [ upload-main-build ]
+    uses: aws-observability/aws-application-signals-test-framework/.github/workflows/node-ec2-default-test.yml@main
+    secrets: inherit
+    with:
+      aws-region: us-east-1
+      staging-instrumentation-name: ${{ inputs.staging-instrumentation-name }}
+      caller-workflow-name: 'main-build'
+
+  ec2-asg:
+    needs: [ upload-main-build ]
+    uses: aws-observability/aws-application-signals-test-framework/.github/workflows/node-ec2-asg-test.yml@main
+    secrets: inherit
+    with:
+      aws-region: us-east-1
+      staging-instrumentation-name: ${{ inputs.staging-instrumentation-name }}
+      caller-workflow-name: 'main-build'
+
+  eks:
+    uses: aws-observability/aws-application-signals-test-framework/.github/workflows/node-eks-test.yml@main
+    secrets: inherit
+    with:
+      aws-region: us-east-1
+      test-cluster-name: 'e2e-node-adot-test'
+      adot-image-name: ${{ inputs.adot-image-name }}
+      caller-workflow-name: 'main-build'
+
+  k8s:
+    uses: aws-observability/aws-application-signals-test-framework/.github/workflows/node-k8s-test.yml@main
+    secrets: inherit
+    with:
+      aws-region: us-east-1
+      adot-image-name: ${{ inputs.adot-image-name }}
+      caller-workflow-name: 'main-build'

.github/workflows/daily-scan.yml

@@ -73,7 +73,7 @@ jobs:
         id: high_scan
         uses: ./.github/actions/image_scan
         with:
-          image-ref: "public.ecr.aws/aws-observability/adot-autoinstrumentation-node:v0.1.0"
+          image-ref: "public.ecr.aws/aws-observability/adot-autoinstrumentation-node:v0.2.0"
           severity: 'CRITICAL,HIGH'
 
       # TODO: Update image to public once available
@@ -82,7 +82,7 @@ jobs:
         id: low_scan
         uses: ./.github/actions/image_scan
         with:
-          image-ref: "public.ecr.aws/aws-observability/adot-autoinstrumentation-node:v0.1.0"
+          image-ref: "public.ecr.aws/aws-observability/adot-autoinstrumentation-node:v0.2.0"
           severity: 'MEDIUM,LOW,UNKNOWN'
 
       - name: Configure AWS Credentials for emitting metrics

.github/workflows/main-build.yml

@@ -5,7 +5,6 @@ on:
     branches:
       - main
       - "release/v*"
-      - e2e-parallel
 
 env:
   AWS_DEFAULT_REGION: us-east-1
@@ -84,15 +83,14 @@ jobs:
       #     pip install pytest
       #     pytest contract-tests/tests
 
-  # TODO - implement E2E tests in NodeJS
-  # application-signals-e2e-test:
-  #   name: "Application Signals E2E Test"
-  #   needs: [ build ]
-  #   uses: ./.github/workflows/application-signals-e2e-test.yml
-  #   secrets: inherit
-  #   permissions:
-  #     id-token: write
-  #     contents: read
-  #   with:
-  #     staging-wheel-name: ${{ needs.build.outputs.staging_wheel_file }}
-  #     adot-image-name: ${{ needs.build.outputs.staging_registry }}/aws-observability/adot-autoinstrumentation-python-staging:${{ needs.build.outputs.python_image_tag }}
+  application-signals-e2e-test:
+    name: "Application Signals E2E Test"
+    needs: [ build ]
+    uses: ./.github/workflows/application-signals-e2e-test.yml
+    secrets: inherit
+    permissions:
+      id-token: write
+      contents: read
+    with:
+      staging-instrumentation-name: ${{ needs.build.outputs.staging_tarball_file }}
+      adot-image-name: ${{ needs.build.outputs.staging_registry }}/aws-observability/adot-autoinstrumentation-node-staging:${{ needs.build.outputs.node_image_tag }}

aws-distro-opentelemetry-node-autoinstrumentation/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws/aws-distro-opentelemetry-node-autoinstrumentation",
-  "version": "0.1.0-dev0",
+  "version": "0.2.0-dev0",
   "description": "This package provides Amazon Web Services distribution of the OpenTelemetry Node Instrumentation, which allows for auto-instrumentation of NodeJS applications.",
   "author": {
     "name": "Amazon Web Services",
@@ -37,7 +37,32 @@
   "bugs": {
     "url": "https://github.com/aws-observability/aws-otel-js-instrumentation/issues"
   },
+  "keywords": [
+    "aws",
+    "amazon",
+    "adot",
+    "adotjs",
+    "adot-js",
+    "adot js",
+    "xray",
+    "x-ray",
+    "x ray",
+    "awsxray",
+    "awsdistroopentelemetry",
+    "opentelemetry",
+    "otel",
+    "awslambda",
+    "nodejs",
+    "trace",
+    "tracing",
+    "profiling",
+    "instrumentation"
+  ],
   "devDependencies": {
+    "@aws-sdk/client-bedrock": "3.632.0",
+    "@aws-sdk/client-bedrock-agent": "3.632.0",
+    "@aws-sdk/client-bedrock-agent-runtime": "3.632.0",
+    "@aws-sdk/client-bedrock-runtime": "3.632.0",
     "@aws-sdk/client-kinesis": "3.632.0",
     "@aws-sdk/client-s3": "3.632.0",
     "@aws-sdk/client-sqs": "3.632.0",

aws-distro-opentelemetry-node-autoinstrumentation/src/aws-attribute-keys.ts

@@ -31,4 +31,8 @@ export const AWS_ATTRIBUTE_KEYS: { [key: string]: string } = {
   AWS_SQS_QUEUE_NAME: 'aws.sqs.queue.name',
   AWS_KINESIS_STREAM_NAME: 'aws.kinesis.stream.name',
   AWS_DYNAMODB_TABLE_NAMES: SEMATTRS_AWS_DYNAMODB_TABLE_NAMES,
+  AWS_BEDROCK_DATA_SOURCE_ID: 'aws.bedrock.data_source.id',
+  AWS_BEDROCK_KNOWLEDGE_BASE_ID: 'aws.bedrock.knowledge_base.id',
+  AWS_BEDROCK_AGENT_ID: 'aws.bedrock.agent.id',
+  AWS_BEDROCK_GUARDRAIL_ID: 'aws.bedrock.guardrail.id',
 };

aws-distro-opentelemetry-node-autoinstrumentation/src/aws-metric-attribute-generator.ts

@@ -55,6 +55,8 @@ const NORMALIZED_DYNAMO_DB_SERVICE_NAME: string = 'AWS::DynamoDB';
 const NORMALIZED_KINESIS_SERVICE_NAME: string = 'AWS::Kinesis';
 const NORMALIZED_S3_SERVICE_NAME: string = 'AWS::S3';
 const NORMALIZED_SQS_SERVICE_NAME: string = 'AWS::SQS';
+const NORMALIZED_BEDROCK_SERVICE_NAME: string = 'AWS::Bedrock';
+const NORMALIZED_BEDROCK_RUNTIME_SERVICE_NAME: string = 'AWS::BedrockRuntime';
 
 const DB_CONNECTION_RESOURCE_TYPE: string = 'DB::Connection';
 // As per https://opentelemetry.io/docs/specs/semconv/resource/#service, if service name is not specified, SDK defaults
@@ -317,10 +319,19 @@ export class AwsMetricAttributeGenerator implements MetricAttributeGenerator {
    * Cloud Control resource format</a> as much as possible, with special attention to services we
    * can detect remote resource information for. Long term, we would like to normalize service name
    * in the upstream.
+   *
+   * For Bedrock, Bedrock Agent, and Bedrock Agent Runtime, we can align with AWS Cloud Control and use
+   * AWS::Bedrock for RemoteService. For BedrockRuntime, we are using AWS::BedrockRuntime
+   * as the associated remote resource (Model) is not listed in Cloud Control.
    */
   private static normalizeRemoteServiceName(span: ReadableSpan, serviceName: string): string {
     if (AwsSpanProcessingUtil.isAwsSDKSpan(span)) {
-      return 'AWS::' + serviceName;
+      const awsSdkServiceMapping: { [key: string]: string } = {
+        BedrockAgent: NORMALIZED_BEDROCK_SERVICE_NAME,
+        BedrockAgentRuntime: NORMALIZED_BEDROCK_SERVICE_NAME,
+        BedrockRuntime: NORMALIZED_BEDROCK_RUNTIME_SERVICE_NAME,
+      };
+      return awsSdkServiceMapping[serviceName] || 'AWS::' + serviceName;
     }
     return serviceName;
   }
@@ -369,6 +380,31 @@ export class AwsMetricAttributeGenerator implements MetricAttributeGenerator {
         remoteResourceIdentifier = SqsUrlParser.getQueueName(
           AwsMetricAttributeGenerator.escapeDelimiters(span.attributes[AWS_ATTRIBUTE_KEYS.AWS_SQS_QUEUE_URL])
         );
+      } else if (AwsSpanProcessingUtil.isKeyPresent(span, AWS_ATTRIBUTE_KEYS.AWS_BEDROCK_AGENT_ID)) {
+        remoteResourceType = NORMALIZED_BEDROCK_SERVICE_NAME + '::Agent';
+        remoteResourceIdentifier = AwsMetricAttributeGenerator.escapeDelimiters(
+          span.attributes[AWS_ATTRIBUTE_KEYS.AWS_BEDROCK_AGENT_ID]
+        );
+      } else if (AwsSpanProcessingUtil.isKeyPresent(span, AWS_ATTRIBUTE_KEYS.AWS_BEDROCK_DATA_SOURCE_ID)) {
+        remoteResourceType = NORMALIZED_BEDROCK_SERVICE_NAME + '::DataSource';
+        remoteResourceIdentifier = AwsMetricAttributeGenerator.escapeDelimiters(
+          span.attributes[AWS_ATTRIBUTE_KEYS.AWS_BEDROCK_DATA_SOURCE_ID]
+        );
+      } else if (AwsSpanProcessingUtil.isKeyPresent(span, AWS_ATTRIBUTE_KEYS.AWS_BEDROCK_GUARDRAIL_ID)) {
+        remoteResourceType = NORMALIZED_BEDROCK_SERVICE_NAME + '::Guardrail';
+        remoteResourceIdentifier = AwsMetricAttributeGenerator.escapeDelimiters(
+          span.attributes[AWS_ATTRIBUTE_KEYS.AWS_BEDROCK_GUARDRAIL_ID]
+        );
+      } else if (AwsSpanProcessingUtil.isKeyPresent(span, AWS_ATTRIBUTE_KEYS.AWS_BEDROCK_KNOWLEDGE_BASE_ID)) {
+        remoteResourceType = NORMALIZED_BEDROCK_SERVICE_NAME + '::KnowledgeBase';
+        remoteResourceIdentifier = AwsMetricAttributeGenerator.escapeDelimiters(
+          span.attributes[AWS_ATTRIBUTE_KEYS.AWS_BEDROCK_KNOWLEDGE_BASE_ID]
+        );
+      } else if (AwsSpanProcessingUtil.isKeyPresent(span, AwsSpanProcessingUtil.GEN_AI_REQUEST_MODEL)) {
+        remoteResourceType = NORMALIZED_BEDROCK_SERVICE_NAME + '::Model';
+        remoteResourceIdentifier = AwsMetricAttributeGenerator.escapeDelimiters(
+          span.attributes[AwsSpanProcessingUtil.GEN_AI_REQUEST_MODEL]
+        );
       }
     } else if (AwsSpanProcessingUtil.isDBSpan(span)) {
       remoteResourceType = DB_CONNECTION_RESOURCE_TYPE;

aws-distro-opentelemetry-node-autoinstrumentation/src/aws-opentelemetry-configurator.ts

@@ -104,7 +104,7 @@ export class AwsOpentelemetryConfigurator {
    * @constructor
    * @param {Instrumentation[]} instrumentations - Auto-Instrumentations to be added to the ADOT Config
    */
-  public constructor(instrumentations: Instrumentation[]) {
+  public constructor(instrumentations: Instrumentation[], useXraySampler: boolean = false) {
     /*
      * Set and Detect Resources via Resource Detectors
      *
@@ -167,7 +167,9 @@ export class AwsOpentelemetryConfigurator {
     // https://github.com/aws-observability/aws-otel-java-instrumentation/blob/a011b8cc29ee32b7f668c04ccfdf64cd30de467c/awsagentprovider/src/main/java/software/amazon/opentelemetry/javaagent/providers/AwsTracerCustomizerProvider.java#L36
     this.idGenerator = new AWSXRayIdGenerator();
 
-    this.sampler = AwsOpentelemetryConfigurator.customizeSampler(customBuildSamplerFromEnv(this.resource));
+    this.sampler = AwsOpentelemetryConfigurator.customizeSampler(
+      customBuildSamplerFromEnv(this.resource, useXraySampler)
+    );
 
     // default SpanProcessors with Span Exporters wrapped inside AwsMetricAttributesSpanExporter
     const awsSpanProcessorProvider: AwsSpanProcessorProvider = new AwsSpanProcessorProvider(this.resource);
@@ -273,7 +275,13 @@ export class AwsOpentelemetryConfigurator {
         resource: resource,
         readers: [periodicExportingMetricReader],
       });
-      spanProcessors.push(AwsSpanMetricsProcessorBuilder.create(meterProvider, resource).build());
+      spanProcessors.push(
+        AwsSpanMetricsProcessorBuilder.create(
+          meterProvider,
+          resource,
+          meterProvider.forceFlush.bind(meterProvider)
+        ).build()
+      );
     }
   }
 
@@ -285,37 +293,36 @@ export class AwsOpentelemetryConfigurator {
   }
 }
 
-export function customBuildSamplerFromEnv(resource: Resource): Sampler {
-  switch (process.env.OTEL_TRACES_SAMPLER) {
-    case 'xray': {
-      const samplerArgumentEnv: string | undefined = process.env.OTEL_TRACES_SAMPLER_ARG;
-      let endpoint: string | undefined = undefined;
-      let pollingInterval: number | undefined = undefined;
-
-      if (samplerArgumentEnv !== undefined) {
-        const args: string[] = samplerArgumentEnv.split(',');
-        for (const arg of args) {
-          const equalIndex: number = arg.indexOf('=');
-          if (equalIndex === -1) {
-            continue;
-          }
-          const keyValue: string[] = [arg.substring(0, equalIndex), arg.substring(equalIndex + 1)];
-          if (keyValue[0] === 'endpoint') {
-            endpoint = keyValue[1];
-          } else if (keyValue[0] === 'polling_interval') {
-            pollingInterval = Number(keyValue[1]);
-            if (isNaN(pollingInterval)) {
-              pollingInterval = undefined;
-              diag.error('polling_interval in OTEL_TRACES_SAMPLER_ARG must be a valid number');
-            }
+export function customBuildSamplerFromEnv(resource: Resource, useXraySampler: boolean = false): Sampler {
+  if (useXraySampler || process.env.OTEL_TRACES_SAMPLER === 'xray') {
+    const samplerArgumentEnv: string | undefined = process.env.OTEL_TRACES_SAMPLER_ARG;
+    let endpoint: string | undefined = undefined;
+    let pollingInterval: number | undefined = undefined;
+
+    if (samplerArgumentEnv !== undefined) {
+      const args: string[] = samplerArgumentEnv.split(',');
+      for (const arg of args) {
+        const equalIndex: number = arg.indexOf('=');
+        if (equalIndex === -1) {
+          continue;
+        }
+        const keyValue: string[] = [arg.substring(0, equalIndex), arg.substring(equalIndex + 1)];
+        if (keyValue[0] === 'endpoint') {
+          endpoint = keyValue[1];
+        } else if (keyValue[0] === 'polling_interval') {
+          pollingInterval = Number(keyValue[1]);
+          if (isNaN(pollingInterval)) {
+            pollingInterval = undefined;
+            diag.error('polling_interval in OTEL_TRACES_SAMPLER_ARG must be a valid number');
           }
         }
       }
-
-      diag.debug(`XRay Sampler Endpoint: ${endpoint}`);
-      diag.debug(`XRay Sampler Polling Interval: ${pollingInterval}`);
-      return new AwsXRayRemoteSampler({ resource: resource, endpoint: endpoint, pollingInterval: pollingInterval });
     }
+
+    diag.info('AWS XRay Sampler enabled');
+    diag.debug(`XRay Sampler Endpoint: ${endpoint}`);
+    diag.debug(`XRay Sampler Polling Interval: ${pollingInterval}`);
+    return new AwsXRayRemoteSampler({ resource: resource, endpoint: endpoint, pollingInterval: pollingInterval });
   }
 
   return buildSamplerFromEnv();

aws-distro-opentelemetry-node-autoinstrumentation/src/aws-span-metrics-processor-builder.ts

@@ -6,6 +6,7 @@ import { Resource } from '@opentelemetry/resources';
 import { AwsMetricAttributeGenerator } from './aws-metric-attribute-generator';
 import { AwsSpanMetricsProcessor } from './aws-span-metrics-processor';
 import { MetricAttributeGenerator } from './metric-attribute-generator';
+import { ForceFlushFunction } from './aws-span-processing-util';
 
 // Metric instrument configuration constants
 const ERROR: string = 'Error';
@@ -22,18 +23,24 @@ export class AwsSpanMetricsProcessorBuilder {
   // Required builder elements
   private meterProvider: MeterProvider;
   private resource: Resource;
+  private forceFlushFunction: ForceFlushFunction;
 
   // Optional builder elements
   private generator: MetricAttributeGenerator = AwsSpanMetricsProcessorBuilder.DEFAULT_GENERATOR;
   private scopeName: string = AwsSpanMetricsProcessorBuilder.DEFAULT_SCOPE_NAME;
 
-  public static create(meterProvider: MeterProvider, resource: Resource): AwsSpanMetricsProcessorBuilder {
-    return new AwsSpanMetricsProcessorBuilder(meterProvider, resource);
+  public static create(
+    meterProvider: MeterProvider,
+    resource: Resource,
+    meterProviderForceFlusher: ForceFlushFunction
+  ): AwsSpanMetricsProcessorBuilder {
+    return new AwsSpanMetricsProcessorBuilder(meterProvider, resource, meterProviderForceFlusher);
   }
 
-  private constructor(meterProvider: MeterProvider, resource: Resource) {
+  private constructor(meterProvider: MeterProvider, resource: Resource, meterProviderForceFlusher: ForceFlushFunction) {
     this.meterProvider = meterProvider;
     this.resource = resource;
+    this.forceFlushFunction = meterProviderForceFlusher;
   }
 
   /**
@@ -72,7 +79,8 @@ export class AwsSpanMetricsProcessorBuilder {
       faultHistogram,
       latencyHistogram,
       this.generator,
-      this.resource
+      this.resource,
+      this.forceFlushFunction
     );
   }
 }