feat: nodejs opamp instrumentation libraries enabled remote config

agents/nodejs/.dockerignore

@@ -0,0 +1 @@
+node_modules # don't include node_modules in the context, as it takes care of this

agents/nodejs/package.json

@@ -13,15 +13,18 @@
     "@bufbuild/protobuf": "^1.10.0",
     "@opentelemetry/api": "1.8.0",
     "@opentelemetry/auto-instrumentations-node": "0.46.1",
+    "@opentelemetry/context-async-hooks": "1.25.0",
     "@opentelemetry/core": "1.25.0",
     "@opentelemetry/exporter-trace-otlp-grpc": "0.51.1",
     "@opentelemetry/resources": "1.25.0",
-    "@opentelemetry/sdk-node": "0.51.1",
+    "@opentelemetry/sdk-trace-node": "1.25.0",
     "@opentelemetry/semantic-conventions": "1.25.0",
     "axios": "^1.7.2",
+    "semver": "^7.6.2",
     "uuidv7": "^1.0.1"
   },
   "devDependencies": {
+    "@types/semver": "^7.5.8",
     "@types/uuid": "^10.0.0",
     "typescript": "^5.5.2"
   }

agents/nodejs/src/autoinstrumentation.ts

@@ -1,23 +1,38 @@
-import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { diag, DiagConsoleLogger, DiagLogLevel } from "@opentelemetry/api";
+// For development, uncomment the following line to see debug logs
+// diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
+
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { OpAMPClientHttp } from "./opamp";
+import {
+  CompositePropagator,
+  W3CBaggagePropagator,
+  W3CTraceContextPropagator,
+} from "@opentelemetry/core";
+import { OpAMPClientHttp, RemoteConfig } from "./opamp";
 import {
   SEMRESATTRS_TELEMETRY_SDK_LANGUAGE,
   TELEMETRYSDKLANGUAGEVALUES_NODEJS,
   SEMRESATTRS_PROCESS_PID,
 } from "@opentelemetry/semantic-conventions";
 import {
   Resource,
+  detectResourcesSync,
   envDetectorSync,
   hostDetectorSync,
   processDetectorSync,
 } from "@opentelemetry/resources";
-import { DiagConsoleLogger, DiagLogLevel, diag } from "@opentelemetry/api";
+import {
+  AsyncHooksContextManager,
+  AsyncLocalStorageContextManager,
+} from "@opentelemetry/context-async-hooks";
+import { context, propagation } from "@opentelemetry/api";
 import { VERSION } from "./version";
-
-// For development, uncomment the following line to see debug logs
-// diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
+import { InstrumentationLibraries } from "./instrumentation-libraries";
+import {
+  BatchSpanProcessor,
+  NodeTracerProvider,
+} from "@opentelemetry/sdk-trace-node";
+import * as semver from "semver";
 
 // not yet published in '@opentelemetry/semantic-conventions'
 const SEMRESATTRS_TELEMETRY_DISTRO_NAME = "telemetry.distro.name";
@@ -31,45 +46,81 @@ if (!opampServerHost || !instrumentationDeviceId) {
     "Missing required environment variables ODIGOS_OPAMP_SERVER_HOST and ODIGOS_INSTRUMENTATION_DEVICE_ID"
   );
 } else {
-  const opampClient = new OpAMPClientHttp({
-    instrumentationDeviceId: instrumentationDeviceId,
-    opAMPServerHost: opampServerHost,
-    agentDescriptionIdentifyingAttributes: {
-      [SEMRESATTRS_TELEMETRY_SDK_LANGUAGE]: TELEMETRYSDKLANGUAGEVALUES_NODEJS,
-      [SEMRESATTRS_TELEMETRY_DISTRO_VERSION]: VERSION,
-      [SEMRESATTRS_PROCESS_PID]: process.pid,
-    },
-    agentDescriptionNonIdentifyingAttributes: {},
+  const staticResource = new Resource({
+    [SEMRESATTRS_TELEMETRY_DISTRO_NAME]: "odigos",
+    [SEMRESATTRS_TELEMETRY_DISTRO_VERSION]: VERSION,
   });
 
-  opampClient.start();
-
-  const sdk = new NodeSDK({
-    resourceDetectors: [
+  const detectorsResource = detectResourcesSync({
+    detectors: [
       // env detector reads resource attributes from the environment.
       // we don't populate it at the moment, but if the user set anything, this detector will pick it up
       envDetectorSync,
       // info about executable, runtime, command, etc
       processDetectorSync,
       // host name, and arch
       hostDetectorSync,
-      // attributes from OpAMP server, k8s attributes, service name, etc
-      opampClient,
     ],
-    // record additional data about the odigos distro
-    resource: new Resource({
-      [SEMRESATTRS_TELEMETRY_DISTRO_NAME]: "odigos",
+  });
+
+  // span processor
+  const spanProcessor = new BatchSpanProcessor(new OTLPTraceExporter());
+
+  // context manager
+  const ContextManager = semver.gte(process.version, "14.8.0")
+    ? AsyncLocalStorageContextManager
+    : AsyncHooksContextManager;
+  const contextManager = new ContextManager();
+  contextManager.enable();
+  context.setGlobalContextManager(contextManager);
+
+  // propagator
+  const propagator = new CompositePropagator({
+    propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()],
+  });
+  propagation.setGlobalPropagator(propagator);
+
+  // instrumentation libraries
+  const instrumentationLibraries = new InstrumentationLibraries();
+  const localResource = staticResource.merge(detectorsResource);
+
+  const opampClient = new OpAMPClientHttp({
+    instrumentationDeviceId: instrumentationDeviceId,
+    opAMPServerHost: opampServerHost,
+    agentDescriptionIdentifyingAttributes: {
+      [SEMRESATTRS_TELEMETRY_SDK_LANGUAGE]: TELEMETRYSDKLANGUAGEVALUES_NODEJS,
       [SEMRESATTRS_TELEMETRY_DISTRO_VERSION]: VERSION,
-    }),
-    instrumentations: [getNodeAutoInstrumentations()],
-    traceExporter: new OTLPTraceExporter(),
+      [SEMRESATTRS_PROCESS_PID]: process.pid,
+    },
+    agentDescriptionNonIdentifyingAttributes: {},
+    onNewRemoteConfig: (remoteConfig: RemoteConfig) => {
+      const resource = localResource
+        .merge(remoteConfig.sdk.remoteResource);
+
+      // tracer provider
+      const tracerProvider = new NodeTracerProvider({
+        resource,
+      });
+      tracerProvider.addSpanProcessor(spanProcessor);
+      instrumentationLibraries.onNewRemoteConfig(
+        remoteConfig.instrumentationLibraries,
+        remoteConfig.sdk.traceSignal,
+        tracerProvider
+      );
+    },
+    initialPackageStatues: instrumentationLibraries.getPackageStatuses(),
   });
-  sdk.start();
+
+  opampClient.start();
 
   const shutdown = async () => {
     try {
       diag.info("Shutting down OpenTelemetry SDK and OpAMP client");
-      await Promise.all([sdk.shutdown(), opampClient.shutdown()]);
+      await Promise.all([
+        // sdk.shutdown(),
+        opampClient.shutdown(),
+        spanProcessor.shutdown(),
+      ]);
     } catch (err) {
       diag.error("Error shutting down OpenTelemetry SDK and OpAMP client", err);
     }

agents/nodejs/src/instrumentation-libraries.ts

@@ -0,0 +1,110 @@
+import { Instrumentation } from "@opentelemetry/instrumentation";
+import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { ProxyTracerProvider, TracerProvider, diag, trace } from "@opentelemetry/api";
+import {
+  InstrumentationLibraryConfiguration,
+  TraceSignalGeneralConfig,
+} from "./opamp";
+import { PackageStatus } from "./opamp/generated/opamp_pb";
+import { PartialMessage } from "@bufbuild/protobuf";
+
+type OdigosInstrumentation = {
+  otelInstrumentation: Instrumentation;
+};
+
+const calculateLibraryEnabled = (
+  traceSignal: TraceSignalGeneralConfig,
+  instrumentationLibraryEnabled: boolean | undefined,
+): boolean => {
+  // if the signal is disabled globally, no library should be enabled
+  if (!traceSignal.enabled) {
+    return false;
+  }
+
+  // if there is a specific configuration for this library, use it
+  if (instrumentationLibraryEnabled != null) {
+    return instrumentationLibraryEnabled;
+  }
+
+  // if there is no remote config to enable/disable this library, use the default
+  return traceSignal.defaultEnabledValue;
+};
+
+export class InstrumentationLibraries {
+  private instrumentations: Instrumentation[];
+  private instrumentationLibraries: OdigosInstrumentation[];
+
+  private noopTracerProvider: TracerProvider;
+
+  private logger = diag.createComponentLogger({
+    namespace: "@odigos/opentelemetry-node/instrumentation-libraries",
+  });
+
+  constructor() {
+    this.instrumentations = getNodeAutoInstrumentations();
+
+    // trick to get the noop tracer provider which is not exported from @openetelemetry/api
+    this.noopTracerProvider = new ProxyTracerProvider().getDelegate();
+
+    this.instrumentationLibraries = this.instrumentations.map(
+      (otelInstrumentation) => {
+        // start all instrumentations with a noop tracer provider.
+        // the global tracer provider is noop by default, so this is just to make sure
+        otelInstrumentation.setTracerProvider(this.noopTracerProvider);
+
+        const odigosInstrumentation = {
+          otelInstrumentation,
+        };
+
+        return odigosInstrumentation;
+      }
+    );
+  }
+
+  public getPackageStatuses(): PartialMessage<PackageStatus>[] {
+    return this.instrumentations.map((instrumentation) => {
+      return {
+        name: instrumentation.instrumentationName,
+        agentHasVersion: instrumentation.instrumentationVersion,
+      };
+    });
+  }
+
+  public onNewRemoteConfig(
+    configs: InstrumentationLibraryConfiguration[],
+    traceSignal: TraceSignalGeneralConfig,
+    enabledTracerProvider: TracerProvider
+  ) {
+    // it will happen when the pipeline is not setup to receive spans
+    const globalTracerProvider = traceSignal.enabled
+      ? enabledTracerProvider
+      : this.noopTracerProvider;
+    // set global tracer provider to record traces from 3rd party instrumented libraries
+    // or application manual instrumentation
+    trace.setGlobalTracerProvider(globalTracerProvider);
+
+    // make the configs into a map by library name so it's quicker to find the right one
+    const configsMap = new Map<string, InstrumentationLibraryConfiguration>(
+      configs.map((config) => [config.name, config])
+    );
+
+    for (const odigosInstrumentation of this.instrumentationLibraries) {
+
+      // for each installed library, calculate it's specific enabled state
+      // which depends on the global trace signal and the specific library config
+      const instrumentationLibraryConfig = configsMap.get(
+        odigosInstrumentation.otelInstrumentation.instrumentationName
+      );
+      const enabled = calculateLibraryEnabled(
+        traceSignal,
+        instrumentationLibraryConfig?.traces?.enabled,
+      );
+      const tracerProviderInUse = enabled
+        ? enabledTracerProvider
+        : this.noopTracerProvider;
+      odigosInstrumentation.otelInstrumentation.setTracerProvider(
+        tracerProviderInUse
+      );
+    }
+  }
+}