Merge branch 'main' into lambda-layer-E2E

Author: mxiamxia

.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

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
     );
   }
 }

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

@@ -6,6 +6,7 @@ import { Resource } from '@opentelemetry/resources';
 import { ReadableSpan, Span, SpanProcessor } from '@opentelemetry/sdk-trace-base';
 import { SEMATTRS_HTTP_STATUS_CODE } from '@opentelemetry/semantic-conventions';
 import { AttributeMap, MetricAttributeGenerator } from './metric-attribute-generator';
+import { ForceFlushFunction } from './aws-span-processing-util';
 
 /**
  * This processor will generate metrics based on span data. It depends on a
@@ -39,30 +40,41 @@ export class AwsSpanMetricsProcessor implements SpanProcessor {
 
   private generator: MetricAttributeGenerator;
   private resource: Resource;
+  private forceFlushFunction: ForceFlushFunction;
 
   /** Use {@link AwsSpanMetricsProcessorBuilder} to construct this processor. */
   static create(
     errorHistogram: Histogram,
     faultHistogram: Histogram,
     latencyHistogram: Histogram,
     generator: MetricAttributeGenerator,
-    resource: Resource
+    resource: Resource,
+    forceFlushFunction: ForceFlushFunction
   ): AwsSpanMetricsProcessor {
-    return new AwsSpanMetricsProcessor(errorHistogram, faultHistogram, latencyHistogram, generator, resource);
+    return new AwsSpanMetricsProcessor(
+      errorHistogram,
+      faultHistogram,
+      latencyHistogram,
+      generator,
+      resource,
+      forceFlushFunction
+    );
   }
 
   private constructor(
     errorHistogram: Histogram,
     faultHistogram: Histogram,
     latencyHistogram: Histogram,
     generator: MetricAttributeGenerator,
-    resource: Resource
+    resource: Resource,
+    forceFlushFunction: ForceFlushFunction
   ) {
     this.errorHistogram = errorHistogram;
     this.faultHistogram = faultHistogram;
     this.latencyHistogram = latencyHistogram;
     this.generator = generator;
     this.resource = resource;
+    this.forceFlushFunction = forceFlushFunction;
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -129,6 +141,6 @@ export class AwsSpanMetricsProcessor implements SpanProcessor {
   }
 
   public forceFlush(): Promise<void> {
-    return Promise.resolve();
+    return this.forceFlushFunction();
   }
 }

aws-distro-opentelemetry-node-autoinstrumentation/src/aws-span-processing-util.ts

@@ -20,6 +20,8 @@ import { AWS_ATTRIBUTE_KEYS } from './aws-attribute-keys';
 import { AWS_LAMBDA_FUNCTION_NAME_CONFIG, isLambdaEnvironment } from './aws-opentelemetry-configurator';
 import * as SQL_DIALECT_KEYWORDS_JSON from './configuration/sql_dialect_keywords.json';
 
+export type ForceFlushFunction = (options?: any) => Promise<void>;
+
 /** Utility class designed to support shared logic across AWS Span Processors. */
 export class AwsSpanProcessingUtil {
   // Default attribute values if no valid span attribute value is identified
@@ -38,6 +40,10 @@ export class AwsSpanProcessingUtil {
   static MAX_KEYWORD_LENGTH: number = 27;
   static SQL_DIALECT_PATTERN: string = '^(?:' + AwsSpanProcessingUtil.getDialectKeywords().join('|') + ')\\b';
 
+  // TODO: Use Semantic Conventions once upgraded
+  static GEN_AI_REQUEST_MODEL: string = 'gen_ai.request.model';
+  static GEN_AI_SYSTEM: string = 'gen_ai.system';
+
   static getDialectKeywords(): string[] {
     return SQL_DIALECT_KEYWORDS_JSON.keywords;
   }