dd-trace 5.110.0 → 5.112.0

package/packages/dd-trace/src/llmobs/sdk.js

@@ -49,7 +49,7 @@ class LLMObs extends NoopLLMObs {
   }
 
   get enabled () {
-    return this._config.llmobs.enabled ?? false
+    return this._config.llmobs.DD_LLMOBS_ENABLED ?? false
   }
 
   enable (options = {}) {
@@ -75,7 +75,7 @@ class LLMObs extends NoopLLMObs {
     }
 
     // TODO: These configs should be passed through directly at construction time instead.
-    this._config.llmobs.enabled = true
+    this._config.llmobs.DD_LLMOBS_ENABLED = true
     this._config.llmobs.mlApp = options.mlApp
     this._config.llmobs.agentlessEnabled = options.agentlessEnabled
 
@@ -96,7 +96,7 @@ class LLMObs extends NoopLLMObs {
 
     logger.debug('Disabling LLMObs')
 
-    this._config.llmobs.enabled = false
+    this._config.llmobs.DD_LLMOBS_ENABLED = false
 
     // disable writers and channel subscribers
     this._llmobsModule.disable()

package/packages/dd-trace/src/llmobs/span_processor.js

@@ -83,7 +83,7 @@ class LLMObsSpanProcessor {
 
   // TODO: instead of relying on the tagger's weakmap registry, can we use some namespaced storage correlation?
   process (span) {
-    if (!this.#config.llmobs.enabled) return
+    if (!this.#config.llmobs.DD_LLMOBS_ENABLED) return
     // if the span is not in our private tagger map, it is not an llmobs span
     if (!LLMObsTagger.tagMap.has(span)) return
 

package/packages/dd-trace/src/llmobs/tagger.js

@@ -105,7 +105,7 @@ class LLMObsTagger {
     integration,
     _decorator,
   } = {}) {
-    if (!this.#config.llmobs.enabled) return
+    if (!this.#config.llmobs.DD_LLMOBS_ENABLED) return
     if (!kind) return // do not register it in the map if it doesn't have an llmobs span kind
 
     const spanMlApp =
@@ -734,7 +734,7 @@ class LLMObsTagger {
   }
 
   _register (span) {
-    if (!this.#config.llmobs.enabled) return
+    if (!this.#config.llmobs.DD_LLMOBS_ENABLED) return
     if (registry.has(span)) {
       this.#handleFailure(`LLMObs Span "${span._name}" already registered.`)
       return
@@ -744,7 +744,7 @@ class LLMObsTagger {
   }
 
   _setTag (span, key, value) {
-    if (!this.#config.llmobs.enabled) return
+    if (!this.#config.llmobs.DD_LLMOBS_ENABLED) return
     if (!registry.has(span)) {
       this.#handleFailure(`Span "${span._name}" must be an LLMObs generated span.`)
       return

package/packages/dd-trace/src/llmobs/writers/base.js

@@ -229,7 +229,7 @@ class BaseLLMObsWriter {
     }
 
     if (this._agentless) {
-      options.headers['DD-API-KEY'] = this._config.apiKey || ''
+      options.headers['DD-API-KEY'] = this._config.DD_API_KEY || ''
     } else {
       options.headers[EVP_SUBDOMAIN_HEADER_NAME] = this._intake
     }

package/packages/dd-trace/src/opentelemetry/metrics/index.js

@@ -2,6 +2,14 @@
 
 const os = require('os')
 
+const { metrics } = require('@opentelemetry/api')
+
+const { VERSION } = require('../../../../../version')
+const processTags = require('../../process-tags')
+const MeterProvider = require('./meter_provider')
+const PeriodicMetricReader = require('./periodic_metric_reader')
+const OtlpHttpMetricExporter = require('./otlp_http_metric_exporter')
+
 /**
  * @typedef {import('../../config')} Config
  */
@@ -28,11 +36,6 @@ const os = require('os')
  * @package
  */
 
-const { metrics } = require('@opentelemetry/api')
-const MeterProvider = require('./meter_provider')
-const PeriodicMetricReader = require('./periodic_metric_reader')
-const OtlpHttpMetricExporter = require('./otlp_http_metric_exporter')
-
 /**
  * Initializes OpenTelemetry Metrics support
  * @param {import('../../config/config-base')} config - Tracer configuration instance
@@ -75,7 +78,53 @@ function initializeOpenTelemetryMetrics (config) {
   metrics.setGlobalMeterProvider(meterProvider)
 }
 
+function buildResourceAttributes (tags, { reportHostname, otelSemanticsEnabled, service, env, serviceVersion } = {}) {
+  const attrs = {
+    'telemetry.sdk.name': 'datadog',
+    'telemetry.sdk.language': 'nodejs',
+    'telemetry.sdk.version': VERSION,
+  }
+  if (service) attrs['service.name'] = service
+  if (serviceVersion) attrs['service.version'] = serviceVersion
+  if (env) attrs['deployment.environment.name'] = env
+  if (reportHostname) attrs['host.name'] = os.hostname()
+
+  if (!otelSemanticsEnabled) {
+    if (tags?.['runtime-id']) attrs['datadog.runtime_id'] = tags['runtime-id']
+    const processTagsObject = processTags.tagsObject
+    if (processTagsObject) {
+      for (const key of Object.keys(processTagsObject)) {
+        attrs[`datadog.${key}`] = processTagsObject[key]
+      }
+    }
+  }
+  return attrs
+}
+
+function createOtlpSpanStatsExporter (config) {
+  const { OtlpStatsExporter } = require('./otlp_span_stats_exporter')
+  const protocol = config.OTEL_EXPORTER_OTLP_METRICS_PROTOCOL || 'http/json'
+  const resourceAttributes = buildResourceAttributes(config.tags, {
+    reportHostname: config.reportHostname,
+    otelSemanticsEnabled: config.DD_TRACE_OTEL_SEMANTICS_ENABLED,
+    service: config.service,
+    env: config.env,
+    serviceVersion: config.version,
+  })
+  return new OtlpStatsExporter(
+    config.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,
+    protocol,
+    resourceAttributes,
+    config.DD_TRACE_OTEL_SEMANTICS_ENABLED,
+    config.service,
+    config.OTEL_EXPORTER_OTLP_METRICS_HEADERS,
+    config.OTEL_EXPORTER_OTLP_METRICS_TIMEOUT
+  )
+}
+
 module.exports = {
   MeterProvider,
   initializeOpenTelemetryMetrics,
+  buildResourceAttributes,
+  createOtlpSpanStatsExporter,
 }

package/packages/dd-trace/src/opentelemetry/metrics/otlp_span_stats_exporter.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const log = require('../../log')
+const OtlpHttpExporterBase = require('../otlp/otlp_http_exporter_base')
+const OtlpStatsTransformer = require('./otlp_span_stats_transformer')
+
+class OtlpStatsExporter extends OtlpHttpExporterBase {
+  #transformer
+
+  /**
+   * @param {string} url
+   * @param {string} protocol
+   * @param {import('@opentelemetry/api').Attributes} resourceAttributes
+   * @param {boolean} [otelSemanticsEnabled]
+   * @param {string} [defaultService]
+   * @param {Record<string, string>} [headers]
+   * @param {number} [timeout]
+   */
+  constructor (url, protocol, resourceAttributes, otelSemanticsEnabled = false, defaultService = '',
+    headers, timeout = 10_000) {
+    super(url, headers, timeout, protocol, 'span-stats')
+    this.#transformer = new OtlpStatsTransformer(resourceAttributes, protocol, otelSemanticsEnabled, defaultService)
+  }
+
+  /**
+   * @param {Array<{timeNs: number, bucket: import('../../span_stats').SpanBuckets}>} drained
+   * @param {number} bucketSizeNs
+   */
+  export (drained, bucketSizeNs) {
+    if (drained.length === 0) return
+    const payload = this.#transformer.transform(drained, bucketSizeNs)
+    this.sendPayload(payload, (result) => {
+      if (result.code !== 0) {
+        log.error('Failed to export span stats: %s', result.error?.message)
+      }
+    })
+  }
+}
+
+module.exports = { OtlpStatsExporter }

package/packages/dd-trace/src/opentelemetry/metrics/otlp_span_stats_transformer.js

@@ -0,0 +1,169 @@
+'use strict'
+
+const { LogCollapsingLowestDenseDDSketch } = require('../../../../../vendor/dist/@datadog/sketches-js')
+const OtlpTransformerBase = require('../otlp/otlp_transformer_base')
+const { getProtobufTypes } = require('../otlp/protobuf_loader')
+
+const NS_PER_S = 1e9
+
+// Must match libdatadog's EXPLICIT_BOUNDS_SECONDS and OTel spanmetrics connector defaults.
+const EXPLICIT_BOUNDS_SECONDS = [
+  0.002, 0.004, 0.006, 0.008, 0.01, 0.05, 0.1, 0.2, 0.4, 0.8, 1, 1.4, 2, 5, 10, 15,
+]
+
+/**
+ * @param {object} sketch
+ * @returns {number[]}
+ */
+function sketchToFixedHistogram (sketch) {
+  const bucketCounts = new Array(EXPLICIT_BOUNDS_SECONDS.length + 1).fill(0)
+  if (sketch.zeroCount > 0) bucketCounts[0] += sketch.zeroCount
+  const { store, mapping } = sketch
+  for (let key = store.minKey; key <= store.maxKey; key++) {
+    const weight = store.bins[key - store.offset]
+    if (!weight) continue
+    const seconds = mapping.value(key) / NS_PER_S
+    let idx = EXPLICIT_BOUNDS_SECONDS.findIndex((bound) => seconds <= bound)
+    if (idx === -1) idx = EXPLICIT_BOUNDS_SECONDS.length
+    bucketCounts[idx] += weight
+  }
+  return bucketCounts.map((weight) => Math.round(weight))
+}
+
+let _deltaTemporality
+
+function getDeltaTemporality () {
+  if (_deltaTemporality === undefined) {
+    const { protoAggregationTemporality } = getProtobufTypes()
+    _deltaTemporality = protoAggregationTemporality.values.AGGREGATION_TEMPORALITY_DELTA
+  }
+  return _deltaTemporality
+}
+
+const ERROR_STATUS_ATTR = { key: 'status.code', value: { intValue: 2 } }
+
+class OtlpStatsTransformer extends OtlpTransformerBase {
+  #otelSemanticsEnabled
+  #defaultService
+
+  /**
+   * @param {import('@opentelemetry/api').Attributes} resourceAttributes
+   * @param {string} protocol
+   * @param {boolean} [otelSemanticsEnabled]
+   * @param {string} [defaultService]
+   */
+  constructor (resourceAttributes, protocol, otelSemanticsEnabled = false, defaultService = '') {
+    super(resourceAttributes, protocol, 'span-stats')
+    this.#otelSemanticsEnabled = otelSemanticsEnabled
+    this.#defaultService = defaultService
+  }
+
+  /**
+   * @param {Array<{timeNs: number, bucket: import('../../span_stats').SpanBuckets}>} drained
+   * @param {number} bucketSizeNs
+   */
+  transform (drained, bucketSizeNs) {
+    const isJson = this.protocol === 'http/json'
+    const data = {
+      resourceMetrics: [{
+        resource: this.transformResource(),
+        scopeMetrics: this.#buildScopeMetrics(drained, bucketSizeNs, isJson),
+      }],
+    }
+    return isJson
+      ? this.serializeToJson(data)
+      : this.serializeToProtobuf(getProtobufTypes().protoMetricsService, data)
+  }
+
+  #buildScopeMetrics (drained, bucketSizeNs, isJson) {
+    const temporality = isJson ? 'AGGREGATION_TEMPORALITY_DELTA' : getDeltaTemporality()
+
+    const dataPoints = []
+
+    for (const { timeNs, bucket } of drained) {
+      const endTimeNs = timeNs + bucketSizeNs
+      const startNano = isJson ? String(timeNs) : timeNs
+      const endNano = isJson ? String(endTimeNs) : endTimeNs
+
+      for (const aggStats of bucket.values()) {
+        const baseAttrs = this.#buildAttributes(aggStats.aggKey)
+
+        if (this.#otelSemanticsEnabled) {
+          const okDist = new LogCollapsingLowestDenseDDSketch()
+          okDist.merge(aggStats.topLevelOkDistribution)
+          okDist.merge(aggStats.nonTopLevelOkDistribution)
+          const errDist = new LogCollapsingLowestDenseDDSketch()
+          errDist.merge(aggStats.topLevelErrorDistribution)
+          errDist.merge(aggStats.nonTopLevelErrorDistribution)
+          this.#pushPoint(dataPoints, okDist, startNano, endNano, baseAttrs)
+          this.#pushPoint(dataPoints, errDist, startNano, endNano, [...baseAttrs, ERROR_STATUS_ATTR])
+        } else {
+          const tlAttrs = [...baseAttrs, { key: 'datadog.span.top_level', value: { boolValue: true } }]
+          const ntlAttrs = [...baseAttrs, { key: 'datadog.span.top_level', value: { boolValue: false } }]
+          this.#pushPoint(dataPoints, aggStats.topLevelOkDistribution, startNano, endNano, tlAttrs)
+          this.#pushPoint(dataPoints, aggStats.topLevelErrorDistribution, startNano, endNano,
+            [...tlAttrs, ERROR_STATUS_ATTR])
+          this.#pushPoint(dataPoints, aggStats.nonTopLevelOkDistribution, startNano, endNano, ntlAttrs)
+          this.#pushPoint(dataPoints, aggStats.nonTopLevelErrorDistribution, startNano, endNano,
+            [...ntlAttrs, ERROR_STATUS_ATTR])
+        }
+      }
+    }
+
+    if (dataPoints.length === 0) return []
+    return [{
+      metrics: [
+        {
+          name: 'traces.span.sdk.metrics.duration',
+          unit: 's',
+          histogram: { dataPoints, aggregationTemporality: temporality },
+        },
+      ],
+    }]
+  }
+
+  #pushPoint (points, sketch, startNano, endNano, attributes) {
+    if (!sketch || sketch.count === 0) return
+    points.push({
+      attributes,
+      startTimeUnixNano: startNano,
+      timeUnixNano: endNano,
+      count: sketch.count,
+      sum: sketch.sum / NS_PER_S,
+      min: sketch.min / NS_PER_S,
+      max: sketch.max / NS_PER_S,
+      bucketCounts: sketchToFixedHistogram(sketch),
+      explicitBounds: EXPLICIT_BOUNDS_SECONDS,
+    })
+  }
+
+  /**
+   * @param {import('../../span_stats').SpanAggKey} aggKey
+   */
+  #buildAttributes (aggKey) {
+    const raw = { 'span.name': aggKey.resource }
+
+    if (aggKey.service && aggKey.service !== this.#defaultService) {
+      raw['service.name'] = aggKey.service
+    }
+
+    if (aggKey.spanKind) raw['span.kind'] = aggKey.spanKind
+    if (aggKey.statusCode) raw['http.response.status_code'] = Number(aggKey.statusCode)
+    if (aggKey.method) raw['http.request.method'] = aggKey.method
+    if (aggKey.endpoint) raw['http.route'] = aggKey.endpoint
+    if (aggKey.rpcStatusCode !== '') {
+      raw['rpc.response.status_code'] = String(aggKey.rpcStatusCode).toUpperCase()
+    }
+
+    if (!this.#otelSemanticsEnabled) {
+      raw['datadog.operation.name'] = aggKey.name
+      if (aggKey.type) raw['datadog.span.type'] = aggKey.type
+      if (aggKey.synthetics) raw['datadog.origin'] = 'synthetics'
+    }
+
+    return this.transformAttributes(raw)
+  }
+}
+
+module.exports = OtlpStatsTransformer
+module.exports.EXPLICIT_BOUNDS_SECONDS = EXPLICIT_BOUNDS_SECONDS

package/packages/dd-trace/src/opentelemetry/otlp/otlp_http_exporter_base.js

@@ -3,10 +3,12 @@
 const http = require('node:http')
 const https = require('node:https')
 const { URL } = require('node:url')
+const { storage } = require('../../../../datadog-core')
 const log = require('../../log')
 const telemetryMetrics = require('../../telemetry/metrics')
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
+const legacyStorage = storage('legacy')
 
 /**
  * Base class for OTLP HTTP exporters.
@@ -35,18 +37,20 @@ class OtlpHttpExporterBase {
 
     const isJson = protocol === 'http/json'
 
-    // Initialize fields setUrl doesn't touch; it fills in hostname/port/path below.
+    const parsedUrl = new URL(url)
+    this.#transport = parsedUrl.protocol === 'http:' ? http : https
     this.options = {
       method: 'POST',
       timeout,
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port,
+      path: parsedUrl.pathname + parsedUrl.search,
       headers: {
         'Content-Type': isJson ? 'application/json' : 'application/x-protobuf',
         ...headers,
       },
     }
 
-    this.setUrl(url)
-
     this.telemetryTags = [
       `protocol:${this.#transport === https ? 'https' : 'http'}`,
       `encoding:${isJson ? 'json' : 'protobuf'}`,
@@ -84,59 +88,54 @@ class OtlpHttpExporterBase {
       },
     }
 
-    const req = this.#transport.request(options, (res) => {
-      let data = ''
-
-      res.on('data', (chunk) => {
-        data += chunk
+    legacyStorage.run({ noop: true }, () => {
+      const req = this.#transport.request(options, (res) => {
+        let data = ''
+
+        res.on('data', (chunk) => {
+          data += chunk
+        })
+
+        res.once('end', () => {
+          // @ts-expect-error - res.statusCode can be undefined
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resultCallback({ code: 0 })
+          } else {
+            const error = new Error(`HTTP ${res.statusCode}: ${data}`)
+            resultCallback({ code: 1, error })
+          }
+        })
       })
 
-      res.once('end', () => {
-        // @ts-expect-error - res.statusCode can be undefined
-        if (res.statusCode >= 200 && res.statusCode < 300) {
-          resultCallback({ code: 0 })
-        } else {
-          const error = new Error(`HTTP ${res.statusCode}: ${data}`)
-          resultCallback({ code: 1, error })
-        }
+      req.on('error', (error) => {
+        log.error('Error sending OTLP %s:', this.signalType, error)
+        resultCallback({ code: 1, error })
       })
-    })
 
-    req.on('error', (error) => {
-      log.error('Error sending OTLP %s:', this.signalType, error)
-      resultCallback({ code: 1, error })
-    })
+      req.once('timeout', () => {
+        req.destroy()
+        const error = new Error('Request timeout')
+        resultCallback({ code: 1, error })
+      })
 
-    req.once('timeout', () => {
-      req.destroy()
-      const error = new Error('Request timeout')
-      resultCallback({ code: 1, error })
+      req.write(payload)
+      req.end()
     })
-
-    req.write(payload)
-    req.end()
   }
 
   /**
-   * Updates the target URL used by this exporter. The URL is used as-is per the OTel spec: the
-   * caller is responsible for including the signal-specific path (`/v1/traces` etc.).
-   * @param {string} url - New OTLP endpoint URL
+   * Re-targets the exporter to a different URL, updating transport, hostname, port, and path.
+   * @param {string} url
    */
   setUrl (url) {
     const parsedUrl = new URL(url)
+    this.#transport = parsedUrl.protocol === 'http:' ? http : https
     this.options.hostname = parsedUrl.hostname
     this.options.port = parsedUrl.port
     this.options.path = parsedUrl.pathname + parsedUrl.search
-    this.#transport = parsedUrl.protocol === 'http:' ? http : https
-    if (this.telemetryTags !== undefined) {
-      this.telemetryTags[0] = `protocol:${this.#transport === https ? 'https' : 'http'}`
-    }
+    this.telemetryTags[0] = `protocol:${this.#transport === https ? 'https' : 'http'}`
   }
 
-  /**
-   * Shuts down the exporter.
-   * Subclasses can override to add cleanup logic.
-   */
   shutdown () {}
 }
 

package/packages/dd-trace/src/opentelemetry/span.js

@@ -152,6 +152,11 @@ class Span extends BridgeSpanBase {
       hostname: _tracer._hostname,
       integrationName: parentTracer?._isOtelLibrary ? 'otel.library' : 'otel',
       tags: {
+        // Apply global/resource tags (DD_TAGS, OTEL_RESOURCE_ATTRIBUTES) as
+        // defaults, mirroring the native path in opentracing/tracer.js. The
+        // explicit service/resource/span.kind below take precedence, and any
+        // user-set OTel attributes applied via setAttributes() still win.
+        ..._tracer._config.tags,
         [SERVICE_NAME]: _tracer._service,
         [RESOURCE_NAME]: spanName,
         [SPAN_KIND]: spanKindNames[kind],

package/packages/dd-trace/src/opentelemetry/trace/index.js

@@ -45,6 +45,10 @@ function buildResourceAttributes (config) {
   const { service, version, env, ...filteredTags } = config.tags
   Object.assign(resourceAttributes, filteredTags)
 
+  if (config.OTEL_TRACES_SPAN_METRICS_ENABLED) {
+    resourceAttributes['_dd.stats_computed'] = 'true'
+  }
+
   return resourceAttributes
 }
 

package/packages/dd-trace/src/opentelemetry/tracer_provider.js

@@ -68,7 +68,7 @@ class TracerProvider {
       return Promise.reject(new Error('Not started'))
     }
 
-    exporter._writer.flush()
+    exporter._writer?.flush()
     return this._activeProcessor.forceFlush()
   }
 

package/packages/dd-trace/src/opentracing/tracer.js

@@ -45,7 +45,12 @@ class DatadogTracer {
       this._exporter = new Exporter(config, this._prioritySampler)
     }
 
-    this._processor = new SpanProcessor(this._exporter, this._prioritySampler, config)
+    let otlpStatsExporter
+    if (config.OTEL_TRACES_SPAN_METRICS_ENABLED) {
+      const { createOtlpSpanStatsExporter } = require('../opentelemetry/metrics')
+      otlpStatsExporter = createOtlpSpanStatsExporter(config)
+    }
+    this._processor = new SpanProcessor(this._exporter, this._prioritySampler, config, otlpStatsExporter)
     this._url = this._exporter._url
     this._enableGetRumData = config.experimental.enableGetRumData
     this._traceId128BitGenerationEnabled = config.traceId128BitGenerationEnabled

package/packages/dd-trace/src/plugin_manager.js

@@ -158,7 +158,7 @@ module.exports = class PluginManager {
     const {
       logInjection,
       serviceMapping,
-      queryStringObfuscation,
+      DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP,
       site,
       url,
       headerTags,
@@ -169,16 +169,20 @@ module.exports = class PluginManager {
       clientIpHeader,
       DD_TRACE_MEMCACHED_COMMAND_ENABLED,
       DD_TRACE_OTEL_SEMANTICS_ENABLED,
+      DD_TRACE_GRAPHQL_COLLAPSE,
+      DD_TRACE_GRAPHQL_DEPTH,
+      DD_TRACE_GRAPHQL_VARIABLES,
+      DD_TRACE_GRAPHQL_ERROR_EXTENSIONS,
       DD_TEST_SESSION_NAME,
       DD_AGENTLESS_LOG_SUBMISSION_ENABLED,
-      isTestDynamicInstrumentationEnabled,
+      testOptimization,
       isServiceUserProvided,
       middlewareTracingEnabled,
       traceWebsocketMessagesEnabled,
       traceWebsocketMessagesInheritSampling,
       traceWebsocketMessagesSeparateTraces,
       experimental,
-      resourceRenamingEnabled,
+      DD_TRACE_RESOURCE_RENAMING_ENABLED,
     } = /** @type {import('./config/config-base')} */ (this._tracerConfig)
 
     const sharedConfig = {
@@ -193,21 +197,21 @@ module.exports = class PluginManager {
       clientIpHeader,
       DD_TEST_SESSION_NAME,
       DD_AGENTLESS_LOG_SUBMISSION_ENABLED,
-      isTestDynamicInstrumentationEnabled,
+      isTestDynamicInstrumentationEnabled: testOptimization.DD_TEST_FAILED_TEST_REPLAY_ENABLED,
       isServiceUserProvided,
       traceWebsocketMessagesEnabled,
       traceWebsocketMessagesInheritSampling,
       traceWebsocketMessagesSeparateTraces,
       experimental,
-      resourceRenamingEnabled,
+      resourceRenamingEnabled: DD_TRACE_RESOURCE_RENAMING_ENABLED,
     }
 
     if (logInjection !== undefined) {
       sharedConfig.logInjection = logInjection
     }
 
-    if (queryStringObfuscation !== undefined) {
-      sharedConfig.queryStringObfuscation = queryStringObfuscation
+    if (DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP !== undefined) {
+      sharedConfig.queryStringObfuscation = DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP
     }
 
     if (serviceMapping && serviceMapping[name]) {
@@ -225,6 +229,18 @@ module.exports = class PluginManager {
       sharedConfig.middleware = middlewareTracingEnabled
     }
 
+    // The graphql `DD_TRACE_GRAPHQL_*` options are global on purpose: they feed
+    // the plugin config as a base that a programmatic `tracer.use('graphql', …)`
+    // overrides, and stay on the Config singleton so remote config and config
+    // telemetry observe them. Forwarded only for graphql so other plugins do not
+    // carry keys they ignore. The plugin-facing names drop the prefix.
+    if (name === 'graphql') {
+      sharedConfig.collapse = DD_TRACE_GRAPHQL_COLLAPSE
+      sharedConfig.depth = DD_TRACE_GRAPHQL_DEPTH
+      sharedConfig.variables = DD_TRACE_GRAPHQL_VARIABLES
+      sharedConfig.errorExtensions = DD_TRACE_GRAPHQL_ERROR_EXTENSIONS
+    }
+
     return sharedConfig
   }
 }