enable sigv4 in auto instrumentation

Author: liustve

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

@@ -14,6 +14,9 @@ import {
 import { OTLPTraceExporter as OTLPGrpcTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
 import { OTLPTraceExporter as OTLPHttpTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 import { OTLPTraceExporter as OTLPProtoTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto';
+import { OTLPLogExporter as OTLPGrpcLogExporter } from '@opentelemetry/exporter-logs-otlp-grpc';
+import { OTLPLogExporter as OTLPHttpLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+import { OTLPLogExporter as OTLPProtoLogExporter } from '@opentelemetry/exporter-logs-otlp-proto';
 import { ZipkinExporter } from '@opentelemetry/exporter-zipkin';
 import { AWSXRayIdGenerator } from '@opentelemetry/id-generator-aws-xray';
 import { Instrumentation } from '@opentelemetry/instrumentation';
@@ -50,6 +53,14 @@ import {
   SpanProcessor,
   TraceIdRatioBasedSampler,
 } from '@opentelemetry/sdk-trace-base';
+
+import {
+  BatchLogRecordProcessor,
+  ConsoleLogRecordExporter,
+  LogRecordExporter,
+  LogRecordProcessor,
+  SimpleLogRecordProcessor,
+} from '@opentelemetry/sdk-logs';
 import { SEMRESATTRS_TELEMETRY_AUTO_VERSION } from '@opentelemetry/semantic-conventions';
 import { AlwaysRecordSampler } from './always-record-sampler';
 import { AttributePropagatingSpanProcessorBuilder } from './attribute-propagating-span-processor-builder';
@@ -61,6 +72,8 @@ import { OTLPUdpSpanExporter } from './otlp-udp-exporter';
 import { AwsXRayRemoteSampler } from './sampler/aws-xray-remote-sampler';
 // This file is generated via `npm run compile`
 import { LIB_VERSION } from './version';
+import { OTLPAwsLogExporter } from './exporter/otlp/aws/logs/otlp-aws-log-exporter';
+import { AwsBatchLogRecordProcessor } from './exporter/otlp/aws/logs/aws-batch-log-record-processor';
 
 const XRAY_OTLP_ENDPOINT_PATTERN = '^https://xray\\.([a-z0-9-]+)\\.amazonaws\\.com/v1/traces$';
 
@@ -69,6 +82,7 @@ const APPLICATION_SIGNALS_EXPORTER_ENDPOINT_CONFIG: string = 'OTEL_AWS_APPLICATI
 const METRIC_EXPORT_INTERVAL_CONFIG: string = 'OTEL_METRIC_EXPORT_INTERVAL';
 const DEFAULT_METRIC_EXPORT_INTERVAL_MILLIS: number = 60000;
 export const AWS_LAMBDA_FUNCTION_NAME_CONFIG: string = 'AWS_LAMBDA_FUNCTION_NAME';
+export const AGENT_OBSERVABILITY_ENABLED = 'AGENT_OBSERVABILITY_ENABLED';
 const AWS_XRAY_DAEMON_ADDRESS_CONFIG: string = 'AWS_XRAY_DAEMON_ADDRESS';
 const FORMAT_OTEL_SAMPLED_TRACES_BINARY_PREFIX = 'T1S';
 const FORMAT_OTEL_UNSAMPLED_TRACES_BINARY_PREFIX = 'T1U';
@@ -421,15 +435,18 @@ export class ApplicationSignalsExporterProvider {
 // TODO: `TracerProviderWithEnvExporters` is not exported, thus its useful static methods that
 // provides some default SpanExporter configurations are unavailable. Ideally, we could contribute
 // to upstream to export `TracerProviderWithEnvExporters`
+export type SignalType = 'LOGS' | 'TRACES' | 'METRICS';
+
 export class AwsSpanProcessorProvider {
-  private _configuredExporters: SpanExporter[] = [];
+  private _configuredSpanExporters: SpanExporter[] = [];
+  private _configuredLogExporters: LogRecordExporter[] = [];
   private _spanProcessors: SpanProcessor[] = [];
+  private _logRecordProcessors: LogRecordProcessor[] = [];
   private resource: Resource;
 
-  static configureOtlp(): SpanExporter {
-    const otlp_exporter_traces_endpoint = process.env['OTEL_EXPORTER_OTLP_TRACES_ENDPOINT'];
+  static configureOtlp(signal: SignalType): SpanExporter | LogRecordExporter {
     // eslint-disable-next-line @typescript-eslint/typedef
-    let protocol = this.getOtlpProtocol();
+    let protocol = this.getOtlpProtocol(signal);
 
     // If `isLambdaEnvironment` is true, we will default to exporting OTel spans via `udp_exporter` to Fluxpump,
     // regardless of whether `AppSignals` is true or false.
@@ -438,40 +455,79 @@ export class AwsSpanProcessorProvider {
     if (!hasCustomOtlpTraceEndpoint() && isLambdaEnvironment()) {
       protocol = 'udp';
     }
-    switch (protocol) {
-      case 'grpc':
-        return new OTLPGrpcTraceExporter();
-      case 'http/json':
-        return new OTLPHttpTraceExporter();
-      case 'http/protobuf':
-        if (otlp_exporter_traces_endpoint && isXrayOtlpEndpoint(otlp_exporter_traces_endpoint)) {
-          diag.debug('Detected XRay OTLP Traces endpoint. Switching exporter to OtlpAwsSpanExporter');
-          return new OTLPAwsSpanExporter(otlp_exporter_traces_endpoint);
-        }
-        return new OTLPProtoTraceExporter();
-      case 'udp':
-        diag.debug('Detected AWS Lambda environment and enabling UDPSpanExporter');
-        return new OTLPUdpSpanExporter(getXrayDaemonEndpoint(), FORMAT_OTEL_SAMPLED_TRACES_BINARY_PREFIX);
-      default:
-        diag.warn(`Unsupported OTLP traces protocol: ${protocol}. Using http/protobuf.`);
-        if (otlp_exporter_traces_endpoint && isXrayOtlpEndpoint(otlp_exporter_traces_endpoint)) {
-          diag.debug('Detected XRay OTLP Traces endpoint. Switching exporter to OtlpAwsSpanExporter');
-          return new OTLPAwsSpanExporter(otlp_exporter_traces_endpoint);
-        }
-        return new OTLPProtoTraceExporter();
+
+    return this.getExporterBasedOnProtocol(protocol, signal);
+  }
+
+  static getExporterBasedOnProtocol(protocol: string, signal: SignalType): SpanExporter | LogRecordExporter {
+    const otlpExporterTracesEndpoint = process.env['OTEL_EXPORTER_OTLP_TRACES_ENDPOINT'];
+    const otlpExporterLogsEndpoint = process.env['OTEL_EXPORTER_OTLP_LOGS_ENDPOINT'];
+
+    if (signal === 'LOGS') {
+      switch (protocol) {
+        case 'grpc':
+          return new OTLPGrpcLogExporter();
+        case 'http/json':
+          return new OTLPHttpLogExporter();
+        case 'http/protobuf':
+          return new OTLPProtoLogExporter();
+        default:
+          diag.warn(`Unsupported OTLP traces protocol: ${protocol}. Using http/protobuf.`);
+          if (otlpExporterLogsEndpoint && isXrayOtlpEndpoint(otlpExporterLogsEndpoint)) {
+            diag.debug('Detected CloudWatch Logs OTLP Logs endpoint. Switching exporter to OTLPAwsLogExporter');
+            return new OTLPAwsLogExporter(otlpExporterLogsEndpoint);
+          }
+          return new OTLPProtoLogExporter();
+      }
+    }
+
+    if (signal === 'TRACES') {
+      switch (protocol) {
+        case 'grpc':
+          return new OTLPGrpcTraceExporter();
+        case 'http/json':
+          return new OTLPHttpTraceExporter();
+        case 'http/protobuf':
+          return new OTLPProtoTraceExporter();
+        case 'udp':
+          diag.debug('Detected AWS Lambda environment and enabling UDPSpanExporter');
+          return new OTLPUdpSpanExporter(getXrayDaemonEndpoint(), FORMAT_OTEL_SAMPLED_TRACES_BINARY_PREFIX);
+        default:
+          diag.warn(`Unsupported OTLP traces protocol: ${protocol}. Using http/protobuf.`);
+          if (otlpExporterTracesEndpoint && isXrayOtlpEndpoint(otlpExporterTracesEndpoint)) {
+            diag.debug('Detected XRay OTLP Traces endpoint. Switching exporter to OtlpAwsSpanExporter');
+            return new OTLPAwsSpanExporter(otlpExporterTracesEndpoint);
+          }
+          return new OTLPProtoTraceExporter();
+      }
     }
+
+    return new OTLPProtoTraceExporter();
   }
 
-  static getOtlpProtocol(): string {
+  static getOtlpProtocol(signal: SignalType): string {
     // eslint-disable-next-line @typescript-eslint/typedef
     const parsedEnvValues = getEnvWithoutDefaults();
 
-    return (
-      parsedEnvValues.OTEL_EXPORTER_OTLP_TRACES_PROTOCOL ??
-      parsedEnvValues.OTEL_EXPORTER_OTLP_PROTOCOL ??
-      getEnv().OTEL_EXPORTER_OTLP_TRACES_PROTOCOL ??
-      getEnv().OTEL_EXPORTER_OTLP_PROTOCOL
-    );
+    if (signal === 'TRACES') {
+      return (
+        parsedEnvValues.OTEL_EXPORTER_OTLP_TRACES_PROTOCOL ??
+        parsedEnvValues.OTEL_EXPORTER_OTLP_PROTOCOL ??
+        getEnv().OTEL_EXPORTER_OTLP_TRACES_PROTOCOL ??
+        getEnv().OTEL_EXPORTER_OTLP_PROTOCOL
+      );
+    }
+
+    if (signal === 'LOGS') {
+      return (
+        parsedEnvValues.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL ??
+        parsedEnvValues.OTEL_EXPORTER_OTLP_PROTOCOL ??
+        getEnv().OTEL_EXPORTER_OTLP_LOGS_PROTOCOL ??
+        getEnv().OTEL_EXPORTER_OTLP_PROTOCOL
+      );
+    }
+
+    return parsedEnvValues.OTEL_EXPORTER_OTLP_PROTOCOL ?? getEnv().OTEL_EXPORTER_OTLP_METRICS_PROTOCOL;
   }
 
   private static configureJaeger() {
@@ -489,58 +545,81 @@ export class AwsSpanProcessorProvider {
     }
   }
 
-  protected static _registeredExporters: Map<string, () => SpanExporter> = new Map<string, () => SpanExporter>([
-    ['otlp', () => this.configureOtlp()],
+  protected static _registeredTraceExporters: Map<string, () => SpanExporter> = new Map<string, () => SpanExporter>([
+    ['otlp', () => this.configureOtlp('TRACES') as SpanExporter],
     ['zipkin', () => new ZipkinExporter()],
     ['jaeger', () => this.configureJaeger()],
     ['console', () => new ConsoleSpanExporter()],
   ]);
 
+  protected static _registeredLogRecordExporters: Map<string, () => LogRecordExporter> = new Map<
+    string,
+    () => LogRecordExporter
+  >([
+    ['otlp', () => this.configureOtlp('LOGS') as LogRecordExporter],
+    ['logging', () => new ConsoleLogRecordExporter()],
+    ['console', () => new ConsoleLogRecordExporter()],
+  ]);
+
   public constructor(resource: Resource) {
     this.resource = resource;
 
     // eslint-disable-next-line @typescript-eslint/typedef
-    let traceExportersList = this.filterBlanksAndNulls(Array.from(new Set(getEnv().OTEL_TRACES_EXPORTER.split(','))));
+    const traceExportersList = this.filterBlanksAndNulls(Array.from(new Set(getEnv().OTEL_TRACES_EXPORTER.split(','))));
+    const logsExportersList = this.filterBlanksAndNulls(Array.from(new Set(getEnv().OTEL_LOGS_EXPORTER.split(','))));
 
-    if (traceExportersList[0] === 'none') {
-      diag.warn('OTEL_TRACES_EXPORTER contains "none". SDK will not be initialized.');
-    } else if (traceExportersList.length === 0) {
-      diag.warn('OTEL_TRACES_EXPORTER is empty. Using default otlp exporter.');
+    this._configuredSpanExporters = this.createExportersFromList(traceExportersList, 'TRACES') as SpanExporter[];
+    this._configuredLogExporters = this.createExportersFromList(logsExportersList, 'LOGS') as LogRecordExporter[];
 
-      traceExportersList = ['otlp'];
-      this.createExportersFromList(traceExportersList);
+    this._spanProcessors = this.configureSpanProcessors(this._configuredSpanExporters);
+    this._logRecordProcessors = this.configureLogRecordProcessors(this._configuredLogExporters);
+  }
 
-      this._spanProcessors = this.configureSpanProcessors(this._configuredExporters);
-    } else {
-      if (traceExportersList.length > 1 && traceExportersList.includes('none')) {
-        diag.warn('OTEL_TRACES_EXPORTER contains "none" along with other exporters. Using default otlp exporter.');
-        traceExportersList = ['otlp'];
-      }
+  private createExportersFromList(exportersList: string[], signal: SignalType) {
+    let exporterNames: string[] = exportersList;
+    const envVar = `OTEL_${signal}_EXPORTER`;
 
-      this.createExportersFromList(traceExportersList);
+    if (exporterNames.length === 0) {
+      diag.warn(`${envVar} is empty. Using default otlp exporter.`);
+      exporterNames = ['otlp'];
+    }
 
-      if (this._configuredExporters.length > 0) {
-        this._spanProcessors = this.configureSpanProcessors(this._configuredExporters);
-      } else {
-        diag.warn('Unable to set up trace exporter(s) due to invalid exporter and/or protocol values.');
-      }
+    if (exporterNames.length === 1 && exporterNames[0] === 'none') {
+      diag.warn(`${envVar}  is "none". SDK will not be initialized.`);
     }
-  }
 
-  private createExportersFromList(exporterList: string[]) {
-    exporterList.forEach(exporterName => {
-      // eslint-disable-next-line @typescript-eslint/typedef
-      const exporter = this._getSpanExporter(exporterName);
-      if (exporter) {
-        this._configuredExporters.push(exporter);
-      } else {
-        diag.warn(`Unrecognized OTEL_TRACES_EXPORTER value: ${exporterName}.`);
+    if (exporterNames.length > 1 && exporterNames.includes('none')) {
+      diag.warn(`${envVar}  contains "none" along with other exporters. Using default otlp exporter.`);
+      exporterNames = ['otlp'];
+    }
+
+    if (exporterNames.length > 0) {
+      const exporters = [];
+      for (const exporterName in exporterNames) {
+        const exporter = this._getExporter(exporterName, signal);
+        if (exporter) {
+          exporters.push(exporter);
+        } else {
+          diag.warn(`Unrecognized ${envVar} value: ${exporterName}.`);
+        }
       }
-    });
+      return exporters;
+    } else {
+      diag.warn(`Unable to set up ${signal.toLowerCase} exporter(s) due to invalid exporter and/or protocol values.`);
+      return [];
+    }
   }
 
-  protected _getSpanExporter(name: string): SpanExporter | undefined {
-    return AwsSpanProcessorProvider._registeredExporters.get(name)?.();
+  protected _getExporter(name: string, signal: SignalType): SpanExporter | LogRecordExporter | undefined {
+    if (signal == 'LOGS') {
+      return AwsSpanProcessorProvider._registeredLogRecordExporters.get(name)?.();
+    }
+
+    if (signal == 'TRACES') {
+      return AwsSpanProcessorProvider._registeredTraceExporters.get(name)?.();
+    }
+
+    return undefined;
   }
 
   private configureSpanProcessors(exporters: SpanExporter[]): (BatchSpanProcessor | SimpleSpanProcessor)[] {
@@ -556,6 +635,17 @@ export class AwsSpanProcessorProvider {
     });
   }
 
+  private configureLogRecordProcessors(
+    exporters: LogRecordExporter[]
+  ): (BatchLogRecordProcessor | SimpleLogRecordProcessor)[] {
+    return exporters.map(exporter => {
+      if (exporter instanceof ConsoleLogRecordExporter) {
+        return new SimpleLogRecordProcessor(exporter);
+      }
+      return new BatchLogRecordProcessor(exporter);
+    });
+  }
+
   private filterBlanksAndNulls(list: string[]): string[] {
     return list.map(item => item.trim()).filter(s => s !== 'null' && s !== '');
   }