fix(otel): share the application's @opentelemetry/api-logs copy

The logs pipeline registers a global provider through
@opentelemetry/api-logs the same way the tracer bridge registers through
@opentelemetry/api, so dd-trace bundling its own copy risks the
first-writer-wins global diverging from the copy the application reads.
Resolve the application's copy instead and stop shipping our own, which
also drops a package from the install for serverless.

1. The api loader is generalized to any OpenTelemetry API package via
   forPackage(); the logs provider loads api-logs through it.
2. @opentelemetry/api-logs becomes an optional peerDependency instead of
   a bundled optionalDependency.
3. The peer-dep config guard is now per-flag: DD_METRICS_OTEL_ENABLED
   needs @opentelemetry/api; DD_LOGS_OTEL_ENABLED also needs
   @opentelemetry/api-logs, so a missing api-logs disables OTel logs and
   leaves DD log injection on instead of crashing the host.

Author: BridgeAR

package.json

@@ -168,11 +168,15 @@
     "opentracing": ">=0.14.7"
   },
   "peerDependencies": {
-    "@opentelemetry/api": ">=1.0.0 <1.10.0"
+    "@opentelemetry/api": ">=1.0.0 <1.10.0",
+    "@opentelemetry/api-logs": "<1.0.0"
   },
   "peerDependenciesMeta": {
     "@opentelemetry/api": {
       "optional": true
+    },
+    "@opentelemetry/api-logs": {
+      "optional": true
     }
   },
   "optionalDependencies": {
@@ -183,7 +187,6 @@
     "@datadog/openfeature-node-server": "2.0.0",
     "@datadog/pprof": "5.15.0",
     "@datadog/wasm-js-rewriter": "5.0.1",
-    "@opentelemetry/api-logs": "<1.0.0",
     "oxc-parser": "^0.132.0"
   },
   "devDependencies": {
@@ -196,6 +199,7 @@
     "@openfeature/core": "^1.11.0",
     "@openfeature/server-sdk": "~1.22.0",
     "@opentelemetry/api": ">=1.0.0 <1.10.0",
+    "@opentelemetry/api-logs": "<1.0.0",
     "@stylistic/eslint-plugin": "^5.10.0",
     "@types/mocha": "^10.0.10",
     "@types/node": "^18.19.106",

packages/dd-trace/src/config/index.js

@@ -342,16 +342,25 @@ class Config extends ConfigBase {
     if (!trackedConfigOrigins.has('dogstatsd.hostname')) {
       setAndTrack(this, 'dogstatsd.hostname', agentHostname)
     }
-    // Both OTel pipelines require the optional @opentelemetry/api peer dep. Disable them before
-    // the log-injection mutual exclusion below, so a missing module leaves DD log injection on.
-    // Warn only when the customer turned the flag on; a default-on flag is disabled silently so
-    // changing a default later does not warn every app that never opted in.
-    if ((this.DD_LOGS_OTEL_ENABLED || this.DD_METRICS_OTEL_ENABLED) &&
-        !require('../opentelemetry/api').isAvailable()) {
-      for (const name of ['DD_LOGS_OTEL_ENABLED', 'DD_METRICS_OTEL_ENABLED']) {
-        if (this[name]) {
+    // Each OTel pipeline requires its optional peer deps. The metrics pipeline needs
+    // @opentelemetry/api; the logs pipeline also registers a global provider through
+    // @opentelemetry/api-logs. Disable a flag whose peer is missing before the
+    // log-injection mutual exclusion below, so a missing module leaves DD log injection
+    // on instead of crashing the host. Warn only when the customer turned the flag on; a
+    // default-on flag is disabled silently so changing a default later does not warn
+    // every app that never opted in.
+    if (this.DD_LOGS_OTEL_ENABLED || this.DD_METRICS_OTEL_ENABLED) {
+      const otelApi = require('../opentelemetry/api')
+      const requiredPeers = {
+        DD_METRICS_OTEL_ENABLED: ['@opentelemetry/api'],
+        DD_LOGS_OTEL_ENABLED: ['@opentelemetry/api', '@opentelemetry/api-logs'],
+      }
+      for (const [name, peers] of Object.entries(requiredPeers)) {
+        if (!this[name]) continue
+        const missing = peers.find(peer => !otelApi.forPackage(peer).isAvailable())
+        if (missing) {
           if (trackedConfigOrigins.has(name)) {
-            log.warn('@opentelemetry/api is not installed; disabling %s', name)
+            log.warn('%s is not installed; disabling %s', missing, name)
           }
           setAndTrack(this, name, false)
         }

packages/dd-trace/src/opentelemetry/api.js

@@ -4,15 +4,13 @@ const { DD_MAJOR } = require('../../../../version')
 const satisfies = require('../../../../vendor/dist/semifies')
 const log = require('../log')
 
-const PACKAGE_NAME = '@opentelemetry/api'
-
-// undefined: not resolved yet; null: resolved and absent; object: resolved api.
-/** @type {typeof import('@opentelemetry/api') | null | undefined} */
-let cachedApi
-// Absolute path of the resolved package entrypoint, used to read its version lazily.
-/** @type {string | undefined} */
-let cachedEntry
-let warned = false
+// The consequence of resolving an unsupported version differs per package: an
+// out-of-range @opentelemetry/api silently downgrades spans to no-ops (issue #6882),
+// while @opentelemetry/api-logs only drops the records it cannot serialize.
+const UNSUPPORTED_CONSEQUENCE = {
+  '@opentelemetry/api': 'OpenTelemetry spans may run as no-ops.',
+  '@opentelemetry/api-logs': 'OpenTelemetry log records may be dropped.',
+}
 
 // Node builtins are required lazily inside the helpers below rather than at module
 // scope. This module is loaded from the config initialization path to answer
@@ -23,7 +21,7 @@ let warned = false
 
 /**
  * `createRequire` rooted at the application entrypoint, used to resolve the copy
- * of `@opentelemetry/api` the user's code loads rather than dd-trace's own.
+ * of the package the user's code loads rather than dd-trace's own.
  *
  * @returns {NodeRequire | undefined}
  */
@@ -38,59 +36,55 @@ function applicationRequire () {
 
 /**
  * @param {NodeRequire} req
- * @returns {{ api: typeof import('@opentelemetry/api'), entry: string } | undefined}
+ * @param {string} packageName
+ * @returns {{ api: object, entry: string } | undefined}
  */
-function resolveFrom (req) {
+function resolveFrom (req, packageName) {
   try {
-    return { api: req(PACKAGE_NAME), entry: req.resolve(PACKAGE_NAME) }
+    return { api: req(packageName), entry: req.resolve(packageName) }
   } catch {}
 }
 
 /**
- * @returns {{ api: typeof import('@opentelemetry/api'), entry: string } | undefined}
+ * @param {string} packageName
+ * @returns {{ api: object, entry: string } | undefined}
  */
-function resolveApi () {
-  // v6 declares @opentelemetry/api as an optional peer dependency, so a single
-  // shared copy lives in the application and dd-trace's own require resolves it.
+function resolveApi (packageName) {
+  // v6 declares the OpenTelemetry API packages as optional peer dependencies, so a
+  // single shared copy lives in the application and dd-trace's own require resolves it.
   if (DD_MAJOR >= 6) {
-    return resolveFrom(require)
+    return resolveFrom(require, packageName)
   }
-  // v5 bundles @opentelemetry/api as an optional dependency, so dd-trace's own
-  // require can resolve its bundled (older) copy instead of the application's.
-  // The OTel global API rejects a provider registered by a copy older than the
-  // reader's, which silently downgrades every span to a no-op (issue #6882).
-  // Prefer the application's copy and fall back to dd-trace's bundled one.
+  // v5 bundles the OpenTelemetry API packages as optional dependencies, so dd-trace's
+  // own require can resolve its bundled (older) copy instead of the application's. The
+  // OTel global API rejects a provider registered by a copy older than the reader's,
+  // which silently downgrades every span to a no-op (issue #6882). Prefer the
+  // application's copy and fall back to dd-trace's bundled one.
   const appRequire = applicationRequire()
-  return (appRequire && resolveFrom(appRequire)) || resolveFrom(require)
-}
-
-function ensureResolved () {
-  if (cachedApi !== undefined) return
-  const resolved = resolveApi()
-  cachedApi = resolved?.api ?? null
-  cachedEntry = resolved?.entry
+  return (appRequire && resolveFrom(appRequire, packageName)) || resolveFrom(require, packageName)
 }
 
 /**
  * Reads the package version by walking up from the resolved entrypoint. The
- * package blocks `require('@opentelemetry/api/package.json')` through its
- * `exports` map, so the version is read from disk instead. `require-package-json`
- * resolves against a module's `module.paths`, which on v5 points at dd-trace's copy
- * rather than the application copy this entrypoint was resolved from, so it cannot
- * answer "which copy did we share"; the walk anchors on the resolved entry instead.
+ * package blocks `require('<pkg>/package.json')` through its `exports` map, so the
+ * version is read from disk instead. `require-package-json` resolves against a
+ * module's `module.paths`, which on v5 points at dd-trace's copy rather than the
+ * application copy this entrypoint was resolved from, so it cannot answer "which
+ * copy did we share"; the walk anchors on the resolved entry instead.
  *
  * @param {string} entry - Absolute path to the resolved package entrypoint.
+ * @param {string} packageName
  * @returns {string | undefined}
  */
-function readVersionNear (entry) {
+function readVersionNear (entry, packageName) {
   const { readFileSync } = require('node:fs')
   const { dirname, join, parse } = require('node:path')
   let dir = dirname(entry)
   const { root } = parse(dir)
   while (dir !== root) {
     try {
       const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'))
-      if (pkg.name === PACKAGE_NAME) return pkg.version
+      if (pkg.name === packageName) return pkg.version
     } catch {}
     dir = dirname(dir)
   }
@@ -100,50 +94,97 @@ function readVersionNear (entry) {
  * Warns when the resolved version is outside dd-trace's declared range, read from
  * dd-trace's own package.json so the threshold stays in lockstep with the declaration.
  *
- * @param {string | undefined} version - Resolved `@opentelemetry/api` version.
+ * @param {string} packageName
+ * @param {string | undefined} version - Resolved package version.
  */
-function warnIfUnsupported (version) {
+function warnIfUnsupported (packageName, version) {
   const pkg = require('../../../../package.json')
-  const range = pkg.peerDependencies?.[PACKAGE_NAME] ?? pkg.optionalDependencies?.[PACKAGE_NAME]
+  const range = pkg.peerDependencies?.[packageName] ?? pkg.optionalDependencies?.[packageName]
   if (version && range && !satisfies(version, range)) {
     log.warn(
-      '@opentelemetry/api@%s is outside the range dd-trace supports (%s); OpenTelemetry spans may run as no-ops.',
-      version, range
+      '%s@%s is outside the range dd-trace supports (%s); %s',
+      packageName, version, range, UNSUPPORTED_CONSEQUENCE[packageName]
     )
   }
 }
 
 /**
- * Returns the `@opentelemetry/api` the bridge must share with the application,
- * throwing a clear error when it is not installed. The first successful load
- * warns once if the resolved version is outside dd-trace's supported range.
+ * Builds a loader that shares a single copy of an OpenTelemetry API package between
+ * dd-trace and the application. Each package gets its own cached state so resolution
+ * and the once-only version warning stay independent.
  *
- * @returns {typeof import('@opentelemetry/api')}
+ * @param {string} packageName - The package to resolve (e.g. `@opentelemetry/api`).
+ * @returns {{ load: () => object, isAvailable: () => boolean }}
  */
-function load () {
-  ensureResolved()
-  if (cachedApi === null) {
-    throw new Error(
-      `${PACKAGE_NAME} is not installed but is required to use the OpenTelemetry bridge ` +
-      '(tracer.TracerProvider). Add it as a dependency of your application to enable the bridge.'
-    )
+function createLoader (packageName) {
+  // undefined: not resolved yet; null: resolved and absent; object: resolved api.
+  /** @type {object | null | undefined} */
+  let cachedApi
+  // Absolute path of the resolved package entrypoint, used to read its version lazily.
+  /** @type {string | undefined} */
+  let cachedEntry
+  let warned = false
+
+  function ensureResolved () {
+    if (cachedApi !== undefined) return
+    const resolved = resolveApi(packageName)
+    cachedApi = resolved?.api ?? null
+    cachedEntry = resolved?.entry
   }
-  if (!warned) {
-    warned = true
-    warnIfUnsupported(cachedEntry && readVersionNear(cachedEntry))
+
+  return {
+    /**
+     * Returns the package the bridge must share with the application, throwing a clear
+     * error when it is not installed. The first successful load warns once if the
+     * resolved version is outside dd-trace's supported range.
+     *
+     * @returns {object}
+     */
+    load () {
+      ensureResolved()
+      if (cachedApi === null) {
+        throw new Error(
+          `${packageName} is not installed but is required to use the OpenTelemetry bridge ` +
+          '(tracer.TracerProvider). Add it as a dependency of your application to enable the bridge.'
+        )
+      }
+      if (!warned) {
+        warned = true
+        warnIfUnsupported(packageName, cachedEntry && readVersionNear(cachedEntry, packageName))
+      }
+      return cachedApi
+    },
+
+    /**
+     * Whether the package can be resolved. Kept free of filesystem access so it is
+     * safe to call from the config initialization path.
+     *
+     * @returns {boolean}
+     */
+    isAvailable () {
+      ensureResolved()
+      return cachedApi !== null
+    },
   }
-  return cachedApi
 }
 
+const apiLoader = createLoader('@opentelemetry/api')
+const loaders = new Map([['@opentelemetry/api', apiLoader]])
+
 /**
- * Whether `@opentelemetry/api` can be resolved. Kept free of filesystem access so
- * it is safe to call from the config initialization path.
+ * Returns the shared loader for an OpenTelemetry API package, reusing the cached
+ * loader so every consumer of a package shares one resolution and one warning.
  *
- * @returns {boolean}
+ * @param {string} packageName
+ * @returns {{ load: () => object, isAvailable: () => boolean }}
  */
-function isAvailable () {
-  ensureResolved()
-  return cachedApi !== null
+function forPackage (packageName) {
+  let loader = loaders.get(packageName)
+  if (!loader) {
+    loader = createLoader(packageName)
+    loaders.set(packageName, loader)
+  }
+  return loader
 }
 
-module.exports = { load, isAvailable }
+module.exports = { load: apiLoader.load, isAvailable: apiLoader.isAvailable, forPackage }

packages/dd-trace/src/opentelemetry/logs/logger_provider.js

@@ -1,6 +1,7 @@
 'use strict'
-const { logs } = require('@opentelemetry/api-logs')
-const { context } = require('../api').load()
+const otelApi = require('../api')
+const { logs } = otelApi.forPackage('@opentelemetry/api-logs').load()
+const { context } = otelApi.load()
 const log = require('../../log')
 const ContextManager = require('../context_manager')
 const Logger = require('./logger')