dd-trace 5.103.0 → 5.104.0

package/packages/datadog-plugin-elasticsearch/src/index.js

@@ -5,23 +5,43 @@ const DatabasePlugin = require('../../dd-trace/src/plugins/database')
 class ElasticsearchPlugin extends DatabasePlugin {
   static id = 'elasticsearch'
 
+  #urlTag
+  #methodTag
+  #bodyTag
+  #paramsTag
+
+  constructor (...args) {
+    super(...args)
+
+    // Per-instance because `system` differs on the OpenSearchPlugin subclass.
+    const { system } = this
+    this.#urlTag = `${system}.url`
+    this.#methodTag = `${system}.method`
+    this.#bodyTag = `${system}.body`
+    this.#paramsTag = `${system}.params`
+  }
+
   bindStart (ctx) {
     const { params } = ctx
 
-    const body = getBody(params.body || params.bulkBody)
+    const meta = {
+      'db.type': this.system,
+      [this.#urlTag]: params.path,
+      [this.#methodTag]: params.method,
+      [this.#bodyTag]: getBody(params.body || params.bulkBody),
+    }
+
+    const queryString = params.querystring || params.query
+    if (queryString) {
+      meta[this.#paramsTag] = JSON.stringify(queryString)
+    }
 
     this.startSpan(this.operationName(), {
       service: this.serviceName({ pluginConfig: this.config }),
       resource: `${params.method} ${quantizePath(params.path)}`,
       type: 'elasticsearch',
       kind: 'client',
-      meta: {
-        'db.type': this.system,
-        [`${this.system}.url`]: params.path,
-        [`${this.system}.method`]: params.method,
-        [`${this.system}.body`]: body,
-        [`${this.system}.params`]: JSON.stringify(params.querystring || params.query),
-      },
+      meta,
     }, ctx)
 
     return ctx.currentStore

package/packages/datadog-plugin-graphql/src/utils.js

@@ -7,7 +7,10 @@ function extractErrorIntoSpanEvent (config, span, exc) {
     attributes.type = exc.name
   }
 
-  if (exc.stack) {
+  // graphql-js validation errors carry a lazy `.stack` accessor; reading it
+  // here is the only consumer in the pipeline and pays full V8 symbolisation.
+  const isValidationOnly = exc.locations && !exc.path && !exc.originalError?.stack
+  if (!isValidationOnly && exc.stack) {
     attributes.stacktrace = exc.stack
   }
 

package/packages/datadog-plugin-kafkajs/src/producer.js

@@ -91,6 +91,38 @@ class KafkajsProducerPlugin extends ProducerPlugin {
     }
   }
 
+  finish (ctx) {
+    const span = ctx?.currentStore?.span
+    const result = ctx?.result
+    if (span && Array.isArray(result) && result.length > 0) {
+      // The broker response is one entry per (topic, partition). Each entry
+      // carries a `baseOffset` — the offset assigned to the first record sent
+      // to that partition. We don't know per-partition record counts from the
+      // response, only the starting offset.
+      const offsets = []
+      for (const entry of result) {
+        const offsetAsLong = entry.offset ?? entry.baseOffset
+        if (entry.partition === undefined || offsetAsLong === undefined) continue
+        // Kafka offsets are 64-bit; coercing to Number loses precision past
+        // 2^53. Keep them as strings so the tag matches the exact offset on
+        // long-lived/high-throughput topics.
+        offsets.push({ partition: entry.partition, start_offset: String(offsetAsLong) })
+      }
+      if (offsets.length > 0) {
+        offsets.sort((a, b) => a.partition - b.partition)
+        span.setTag('kafka.messages.offsets', JSON.stringify(offsets))
+      }
+      // Single-message send: the one entry's partition/offset describes the
+      // exact record. Also expose them as flat tags for easy filtering.
+      if (offsets.length === 1 && ctx.messages?.length === 1) {
+        span.setTag('kafka.partition', offsets[0].partition)
+        // Set as a string meta tag (not a metric) to preserve full 64-bit precision.
+        span.setTag('kafka.message.offset', offsets[0].start_offset)
+      }
+    }
+    super.finish(ctx)
+  }
+
   bindStart (ctx) {
     const { topic, messages, bootstrapServers, clusterId, disableHeaderInjection } = ctx
     const span = this.startSpan({

package/packages/datadog-plugin-mongodb-core/src/index.js

@@ -20,6 +20,9 @@ class MongodbCorePlugin extends DatabasePlugin {
 
     this.config.heartbeatEnabled = config.heartbeatEnabled ??
       this._tracerConfig.DD_TRACE_MONGODB_HEARTBEAT_ENABLED
+    this.config.obfuscateQuery = normaliseObfuscateQuery(
+      config.obfuscateQuery ?? this._tracerConfig.DD_TRACE_MONGODB_OBFUSCATE_QUERY
+    )
   }
 
   bindStart (ctx) {
@@ -28,7 +31,7 @@ class MongodbCorePlugin extends DatabasePlugin {
     if (!this.config.heartbeatEnabled && isHeartbeat(ops, this.config)) {
       return
     }
-    const query = getQuery(ops)
+    const query = getQuery(ops, this.config.obfuscateQuery)
     const resource = truncate(getResource(this, ns, query, name))
     const serviceResult = this.serviceName({ pluginConfig: this.config })
     const span = this.startSpan(this.operationName(), {
@@ -106,15 +109,19 @@ function extractQuery (statements) {
   return extractedQueries
 }
 
-function getQuery (cmd) {
+/**
+ * @param {Record<string, unknown> | unknown[] | undefined} cmd
+ * @param {'none' | 'types' | 'redact'} mode
+ */
+function getQuery (cmd, mode) {
   if (!cmd || (typeof cmd !== 'object' && !Array.isArray(cmd))) return
 
-  if (Array.isArray(cmd)) return sanitiseAndStringify(extractQuery(cmd))
-  if (cmd.query) return sanitiseAndStringify(cmd.query)
-  if (cmd.filter) return sanitiseAndStringify(cmd.filter)
-  if (cmd.pipeline) return sanitiseAndStringify(cmd.pipeline)
-  if (cmd.deletes) return sanitiseAndStringify(extractQuery(cmd.deletes))
-  if (cmd.updates) return sanitiseAndStringify(extractQuery(cmd.updates))
+  if (Array.isArray(cmd)) return sanitiseAndStringify(extractQuery(cmd), mode)
+  if (cmd.query) return sanitiseAndStringify(cmd.query, mode)
+  if (cmd.filter) return sanitiseAndStringify(cmd.filter, mode)
+  if (cmd.pipeline) return sanitiseAndStringify(cmd.pipeline, mode)
+  if (cmd.deletes) return sanitiseAndStringify(extractQuery(cmd.deletes), mode)
+  if (cmd.updates) return sanitiseAndStringify(extractQuery(cmd.updates), mode)
 }
 
 function getResource (plugin, ns, query, operationName) {
@@ -133,37 +140,65 @@ function truncate (input) {
 
 // Single-pass sanitisation. The replacer:
 // - skips functions and coerces bigint to its decimal string,
-// - returns '?' for Buffer / BSON Binary on the *original* value (JSON.stringify already invoked
-//   toJSON before calling us; Buffer / Binary do have toJSON outputs we want to suppress),
+// - collapses Buffer / BSON Binary / BSON types without toJSON (MinKey, MaxKey) to a sentinel,
 // - lets JSON.stringify call toJSON on other BSON types (ObjectId, Long, Decimal128, Date, Timestamp, ...)
 //   so the result lands here as a primitive or plain object,
-// - returns '?' for BSON types without toJSON (MinKey, MaxKey) where `value === original`,
-// - tracks depth via an ancestor stack so cycles and depth >= MAX_DEPTH collapse to '?'.
-function sanitiseAndStringify (input) {
+// - tracks depth via an ancestor stack so cycles and depth >= MAX_DEPTH collapse to the sentinel,
+// - in `redact` mode, replaces every primitive leaf (including null) with '?',
+// - in `types` mode, replaces every primitive leaf with the typeof of the *original* value (so a
+//   BSON Date that flattens to a string still reports as 'object'), and 'null' for null.
+// Keys, operator names, and array / pipeline shape are preserved in both modes so the resulting
+// JSON is still a usable query signature.
+/**
+ * @param {Record<string, unknown> | unknown[]} input
+ * @param {'none' | 'types' | 'redact'} mode
+ */
+function sanitiseAndStringify (input, mode) {
   const ancestors = []
   return JSON.stringify(input, function (key, value) {
     if (typeof value === 'function') return
-    if (typeof value === 'bigint') return value.toString()
+    if (typeof value === 'bigint') {
+      if (mode === 'redact') return '?'
+      if (mode === 'types') return 'bigint'
+      return value.toString()
+    }
 
     const original = key === '' ? value : this[key]
     if (typeof original === 'object' && original !== null) {
-      if (Buffer.isBuffer(original)) return '?'
       const bsontype = original._bsontype
-      if (bsontype !== undefined && (bsontype === 'Binary' || value === original)) {
-        return '?'
+      if (Buffer.isBuffer(original) || (bsontype !== undefined && (bsontype === 'Binary' || value === original))) {
+        return mode === 'types' ? 'object' : '?'
       }
     }
 
-    if (value === null || typeof value !== 'object') return value
+    if (value === null || typeof value !== 'object') {
+      if (key === '' || mode === 'none') return value
+      if (mode === 'redact') return '?'
+      return original === null ? 'null' : typeof original
+    }
 
     while (ancestors.length > 0 && ancestors.at(-1) !== this) ancestors.pop()
-    if (ancestors.length >= MAX_DEPTH || ancestors.includes(value)) return '?'
+    if (ancestors.length >= MAX_DEPTH || ancestors.includes(value)) {
+      return mode === 'types' ? 'object' : '?'
+    }
     ancestors.push(value)
 
     return value
   })
 }
 
+/**
+ * Coerce the plugin-config and env values for `obfuscateQuery` to one of the three canonical modes.
+ * Anything outside the enum — including `undefined` — falls back to `'none'`.
+ *
+ * @param {unknown} value
+ * @returns {'none' | 'types' | 'redact'}
+ */
+function normaliseObfuscateQuery (value) {
+  if (value === 'types' || value === 'redact') return value
+  return 'none'
+}
+
 function isHeartbeat (ops, config) {
   // Check if it's a heartbeat command https://github.com/mongodb/specifications/blob/master/source/mongodb-handshake/handshake.md
   return (

package/packages/datadog-plugin-redis/src/index.js

@@ -11,6 +11,17 @@ class RedisPlugin extends CachePlugin {
   static id = 'redis'
   static system = 'redis'
 
+  /** @type {string} */
+  #rawCommandKey
+  /** @type {Map<string | undefined, { name: string, source: string | undefined }>} */
+  #serviceByConnection = new Map()
+  // `nomenclature.config` identity at last cache fill. `withNamingSchema` swaps it without
+  // running this plugin's `configure`, so identity drives invalidation in `bindStart`.
+  /** @type {object | undefined} */
+  #lastNomenclatureConfig
+  /** @type {string | undefined} */
+  #cachedOperationName
+
   constructor (...args) {
     super(...args)
     this._spanType = 'redis'
@@ -25,14 +36,27 @@ class RedisPlugin extends CachePlugin {
       return { noop: true }
     }
 
+    const nomConfig = this._tracer._nomenclature.config
+    if (this.#lastNomenclatureConfig !== nomConfig) {
+      this.#lastNomenclatureConfig = nomConfig
+      this.#cachedOperationName = undefined
+      this.#serviceByConnection.clear()
+    }
+
+    let service = this.#serviceByConnection.get(connectionName)
+    if (service === undefined) {
+      service = this.serviceName({ pluginConfig: this.config, system: this.system, connectionName })
+      this.#serviceByConnection.set(connectionName, service)
+    }
+
     this.startSpan({
       resource,
-      service: this.serviceName({ pluginConfig: this.config, system: this.system, connectionName }),
+      service,
       type: this._spanType,
       meta: {
         'db.type': this._spanType,
         'db.name': db || '0',
-        [`${this._spanType}.raw_command`]: formatCommand(normalizedCommand, args, argsStartIndex),
+        [this.#rawCommandKey]: formatCommand(normalizedCommand, args, argsStartIndex),
         'out.host': connectionOptions.host,
         [CLIENT_PORT_KEY]: connectionOptions.port,
       },
@@ -41,8 +65,19 @@ class RedisPlugin extends CachePlugin {
     return ctx.currentStore
   }
 
+  operationName () {
+    this.#cachedOperationName ??= super.operationName()
+    return this.#cachedOperationName
+  }
+
   configure (config) {
     super.configure(normalizeConfig(config))
+    // Subclasses (iovalkey) overwrite `_spanType` in their constructor, before any `configure`,
+    // so reading it here is stable.
+    this.#rawCommandKey = `${this._spanType}.raw_command`
+    this.#lastNomenclatureConfig = undefined
+    this.#cachedOperationName = undefined
+    this.#serviceByConnection.clear()
   }
 }
 

package/packages/datadog-plugin-undici/src/index.js

@@ -27,6 +27,7 @@ class UndiciPlugin extends HttpClientPlugin {
     // Subscribe to native undici diagnostic channels for undici >= 4.7.0
     // These channels fire for ALL undici requests (fetch, request, stream, etc.)
     this.addSub('undici:request:create', this.#onNativeRequestCreate.bind(this))
+    this.addSub('undici:request:bodySent', this.#onNativeRequestBodySent.bind(this))
     this.addSub('undici:request:headers', this.#onNativeRequestHeaders.bind(this))
     this.addSub('undici:request:trailers', this.#onNativeRequestTrailers.bind(this))
     this.addSub('undici:request:error', this.#onNativeRequestError.bind(this))
@@ -109,12 +110,30 @@ class UndiciPlugin extends HttpClientPlugin {
       span,
       store,
       uri,
+      method,
     })
 
     // Enter the span context
     storage('legacy').enterWith({ ...store, span })
   }
 
+  #onNativeRequestBodySent ({ request }) {
+    const ctx = requestContexts.get(request)
+    if (!ctx || ctx.method !== 'CONNECT') return
+
+    const { span, store } = ctx
+
+    this.config.hooks.request(span, null, null)
+
+    span.finish()
+
+    requestContexts.delete(request)
+
+    if (store) {
+      storage('legacy').enterWith(store)
+    }
+  }
+
   #onNativeRequestHeaders ({ request, response }) {
     const ctx = requestContexts.get(request)
     if (!ctx) return

package/packages/datadog-plugin-vitest/src/index.js

@@ -56,6 +56,16 @@ class VitestPlugin extends CiPlugin {
 
     this.taskToFinishTime = new WeakMap()
 
+    this.addSub('ci:vitest:session:configuration', ({ onDone }) => {
+      const testSessionSpanContext = this.testSessionSpan?.context()
+      const testModuleSpanContext = this.testModuleSpan?.context()
+      onDone({
+        testSessionId: testSessionSpanContext?.toTraceId(),
+        testModuleId: testModuleSpanContext?.toSpanId(),
+        testCommand: this.command,
+      })
+    })
+
     this.addSub('ci:vitest:test:is-new', ({ knownTests, testSuiteAbsolutePath, testName, onDone }) => {
       // if for whatever reason the worker does not receive valid known tests, we don't consider it as new
       if (!knownTests.vitest) {
@@ -299,14 +309,16 @@ class VitestPlugin extends CiPlugin {
     this.addBind('ci:vitest:test-suite:start', (ctx) => {
       const { testSuiteAbsolutePath, frameworkVersion } = ctx
 
-      // TODO: Handle case where the command is not set
-      this.command = this._tracerConfig.DD_CIVISIBILITY_TEST_COMMAND
+      const testCommand = ctx.testCommand || 'vitest run'
+      const { testSessionId, testModuleId } = ctx
+      this.command = testCommand
       this.frameworkVersion = frameworkVersion
-      const testSessionSpanContext = this.tracer.extract('text_map', {
-        // TODO: Handle case where the session ID or module ID is not set
-        'x-datadog-trace-id': this._tracerConfig.DD_CIVISIBILITY_TEST_SESSION_ID,
-        'x-datadog-parent-id': this._tracerConfig.DD_CIVISIBILITY_TEST_MODULE_ID,
-      })
+      const testSessionSpanContext = testSessionId && testModuleId
+        ? this.tracer.extract('text_map', {
+          'x-datadog-trace-id': testSessionId,
+          'x-datadog-parent-id': testModuleId,
+        })
+        : undefined
 
       const trimmedCommand = DD_MAJOR < 6 ? this.command : 'vitest run'
       // test suites run in a different process, so they also need to init the metadata dictionary

package/packages/datadog-shimmer/src/shimmer.js

@@ -82,6 +82,40 @@ function wrapFunction (original, wrapper) {
   return wrapped
 }
 
+/**
+ * Lean variant of `wrapFunction` for the case where the wrapped value is a
+ * user-supplied callback that the user cannot reasonably introspect beyond
+ * `name` and `length`, and the wrapper closure is fully controlled by us.
+ *
+ * Compared to `wrapFunction`, this skips the prototype copy, the
+ * `assertNotClass` guard, and the `Reflect.ownKeys` descriptor-copy loop.
+ * Only `name` and `length` are preserved, and only when the wrapper's
+ * autogenerated values differ -- a wrapper whose closure already has the
+ * right arity / name pays no overhead.
+ *
+ * Use `wrapFunction` instead when any of the following is true: the wrapped
+ * function needs to keep its prototype, has custom own properties the caller
+ * may read, or is `new`-ed.
+ *
+ * @param {Function} original - User-supplied callback being wrapped.
+ * @param {(original: Function) => Function} wrapper - Factory that receives
+ * `original` and returns the wrapper closure.
+ * @returns {Function} The wrapper closure with `name` and `length` preserved.
+ */
+function wrapCallback (original, wrapper) {
+  if (typeof original !== 'function') {
+    return original
+  }
+  const wrapped = wrapper(original)
+  if (wrapped.name !== original.name) {
+    Object.defineProperty(wrapped, 'name', { value: original.name, configurable: true })
+  }
+  if (wrapped.length !== original.length) {
+    Object.defineProperty(wrapped, 'length', { value: original.length, configurable: true })
+  }
+  return wrapped
+}
+
 /**
  * Wraps a method of an object with a wrapper function.
  *
@@ -280,6 +314,7 @@ function assertNotClass (target) {
 
 module.exports = {
   wrap,
+  wrapCallback,
   wrapFunction,
   massWrap,
 }

package/packages/dd-trace/src/appsec/blocking.js

@@ -104,8 +104,8 @@ function getBlockWithContentData (req, specificType, actionParameters) {
   const statusCode = actionParameters?.status_code || 403
 
   const headers = {
-    'Content-Type': type,
-    'Content-Length': Buffer.byteLength(body),
+    'content-type': type,
+    'content-length': Buffer.byteLength(body),
   }
 
   return { body, statusCode, headers }

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

@@ -350,8 +350,15 @@ function onResponseBody ({ req, res, body }) {
 }
 
 function onResponseWriteHead ({ req, res, abortController, statusCode, responseHeaders }) {
-  if (!isEmpty(responseHeaders)) {
-    storedResponseHeaders.set(req, responseHeaders)
+  // Normalize header names to lowercase so downstream consumers see the same shape
+  // regardless of how the caller wrote them.
+  const normalizedResponseHeaders = {}
+  for (const [key, value] of Object.entries(responseHeaders)) {
+    normalizedResponseHeaders[key.toLowerCase()] = value
+  }
+
+  if (!isEmpty(normalizedResponseHeaders)) {
+    storedResponseHeaders.set(req, normalizedResponseHeaders)
   }
 
   // TODO: do not call waf if inside block()
@@ -376,7 +383,7 @@ function onResponseWriteHead ({ req, res, abortController, statusCode, responseH
   const results = waf.run({
     persistent: {
       [addresses.HTTP_INCOMING_RESPONSE_CODE]: String(statusCode),
-      [addresses.HTTP_INCOMING_RESPONSE_HEADERS]: copyHeadersOmitting(responseHeaders, 'set-cookie'),
+      [addresses.HTTP_INCOMING_RESPONSE_HEADERS]: copyHeadersOmitting(normalizedResponseHeaders, 'set-cookie'),
     },
   }, req)
 

package/packages/dd-trace/src/appsec/reporter.js

@@ -50,6 +50,11 @@ const contentHeaderList = [
   'content-language',
 ]
 
+const mandatoryResponseHeaderList = [
+  'content-type',
+  'content-length',
+]
+
 const responseHeaderList = [
   ...contentHeaderList,
   'content-type',
@@ -102,6 +107,8 @@ const EVENT_HEADERS_MAP = mapHeaderAndTags(eventHeadersList, REQUEST_HEADER_TAG_
 
 const RESPONSE_HEADERS_MAP = mapHeaderAndTags(responseHeaderList, RESPONSE_HEADER_TAG_PREFIX)
 
+const MANDATORY_RESPONSE_HEADERS_MAP = mapHeaderAndTags(mandatoryResponseHeaderList, RESPONSE_HEADER_TAG_PREFIX)
+
 const NON_EXTENDED_REQUEST_HEADERS = new Set([...requestHeadersList, ...eventHeadersList])
 const NON_EXTENDED_RESPONSE_HEADERS = new Set(responseHeaderList)
 const REDACTED_HEADERS = new Set(redactedHeadersList)
@@ -168,14 +175,21 @@ function getCollectedHeaders (req, res, shouldCollectEventHeaders, storedRespons
   // Mandatory
   const mandatoryCollectedHeaders = filterHeaders(req.headers, REQUEST_HEADERS_MAP)
 
-  // Basic collection
-  if (!shouldCollectEventHeaders) return mandatoryCollectedHeaders
-
   // Skip the spread when the stored side is empty -- common during the early
   // request lifecycle when no upstream response headers have been captured.
+  const liveResponseHeaders = res?.getHeaders?.()
   const responseHeaders = isEmpty(storedResponseHeaders)
-    ? res.getHeaders()
-    : { ...storedResponseHeaders, ...res.getHeaders() }
+    ? (liveResponseHeaders ?? {})
+    : (liveResponseHeaders ? { ...storedResponseHeaders, ...liveResponseHeaders } : storedResponseHeaders)
+
+  // content-type and content-length are always reported when appsec is enabled,
+  // even without a security event.
+  if (!shouldCollectEventHeaders) {
+    return Object.assign(
+      mandatoryCollectedHeaders,
+      filterHeaders(responseHeaders, MANDATORY_RESPONSE_HEADERS_MAP)
+    )
+  }
 
   const requestEventCollectedHeaders = filterHeaders(req.headers, EVENT_HEADERS_MAP)
   const responseEventCollectedHeaders = filterHeaders(responseHeaders, RESPONSE_HEADERS_MAP)

package/packages/dd-trace/src/ci-visibility/requests/request.js

@@ -14,6 +14,8 @@ const {
 } = require('../../exporters/common/retry')
 const { urlToHttpOptions } = require('../../exporters/common/url-to-http-options-polyfill')
 
+const legacyStorage = storage('legacy')
+
 function parseUrl (urlObjOrString) {
   if (urlObjOrString !== null && typeof urlObjOrString === 'object') {
     return urlToHttpOptions(urlObjOrString)
@@ -75,7 +77,7 @@ function request (data, options, callback) {
   let firstStatusCode = null
 
   const makeRequest = () => {
-    storage('legacy').run({ noop: true }, () => {
+    legacyStorage.run({ noop: true }, () => {
       const req = client.request(opts, (res) => {
         // Capture non-2xx status code as soon as we see it so telemetry preserves it if the retry
         // fails with a network error (no HTTP response) before 'end' fires

package/packages/dd-trace/src/ci-visibility/test-api-manual/test-api-manual-plugin.js

@@ -8,6 +8,8 @@ const {
 } = require('../../plugins/util/test')
 const { storage } = require('../../../../datadog-core')
 
+const legacyStorage = storage('legacy')
+
 class TestApiManualPlugin extends CiPlugin {
   static id = 'test-api-manual'
 
@@ -17,13 +19,13 @@ class TestApiManualPlugin extends CiPlugin {
     this.sourceRoot = process.cwd()
 
     this.unconfiguredAddSub('dd-trace:ci:manual:test:start', ({ testName, testSuite }) => {
-      const store = storage('legacy').getStore()
+      const store = legacyStorage.getStore()
       const testSuiteRelative = getTestSuitePath(testSuite, this.sourceRoot)
       const testSpan = this.startTestSpan(testName, testSuiteRelative)
       this.enter(testSpan, store)
     })
     this.unconfiguredAddSub('dd-trace:ci:manual:test:finish', ({ status, error }) => {
-      const store = storage('legacy').getStore()
+      const store = legacyStorage.getStore()
       const testSpan = store && store.span
       if (testSpan) {
         testSpan.setTag(TEST_STATUS, status)
@@ -35,7 +37,7 @@ class TestApiManualPlugin extends CiPlugin {
       }
     })
     this.unconfiguredAddSub('dd-trace:ci:manual:test:addTags', (tags) => {
-      const store = storage('legacy').getStore()
+      const store = legacyStorage.getStore()
       const testSpan = store && store.span
       if (testSpan) {
         testSpan.addTags(tags)

package/packages/dd-trace/src/config/generated-config-types.d.ts

@@ -324,6 +324,7 @@ export interface GeneratedConfig {
   DD_TRACE_MONGODB_CORE_ENABLED: boolean;
   DD_TRACE_MONGODB_ENABLED: boolean;
   DD_TRACE_MONGODB_HEARTBEAT_ENABLED: boolean;
+  DD_TRACE_MONGODB_OBFUSCATE_QUERY: "none" | "types" | "redact";
   DD_TRACE_MONGOOSE_ENABLED: boolean;
   DD_TRACE_MQUERY_ENABLED: boolean;
   DD_TRACE_MULTER_ENABLED: boolean;

package/packages/dd-trace/src/config/supported-configurations.json

@@ -3133,6 +3133,15 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_MONGODB_OBFUSCATE_QUERY": [
+      {
+        "implementation": "A",
+        "type": "string",
+        "default": "none",
+        "allowed": "none|types|redact",
+        "transform": "toLowerCase"
+      }
+    ],
     "DD_TRACE_MONGOOSE_ENABLED": [
       {
         "implementation": "A",

package/packages/dd-trace/src/crashtracking/crashtracker.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { EOL } = require('node:os')
+
 // Load binding first to not import other modules if it throws
 const libdatadog = require('@datadog/libdatadog')
 const binding = libdatadog.load('crashtracker')
@@ -29,19 +31,29 @@ class Crashtracker {
   start (config) {
     if (this.#started) return this.configure(config)
 
-    this.#started = true
-
     try {
       binding.init(
         this.#getConfig(config),
         this.#getReceiverConfig(),
         this.#getMetadata(config)
       )
+      this.#started = true
+      this.#trackUnhandledExceptions()
     } catch (e) {
       log.error('Error initializing crashtracker', e)
     }
   }
 
+  #trackUnhandledExceptions () {
+    process.once('uncaughtExceptionMonitor', (error, origin) => {
+      try {
+        binding.reportUncaughtExceptionMonitor(error, origin)
+      } catch (e) {
+        process.stderr.write(`Error reporting uncaught exception to crashtracker: ${e.toString()}${EOL}`)
+      }
+    })
+  }
+
   withProfilerSerializing (f) {
     binding.beginProfilerSerializing()
     try {
@@ -58,7 +70,7 @@ class Crashtracker {
   #getConfig (config) {
     const url = getAgentUrl(config)
 
-    // Out-of-process symbolication currently (crashtracker 27.0.0) works on
+    // Out-of-process symbolication currently works on
     // Linux only, does not work on Mac.
     const resolveMode = require('os').platform === 'linux'
       ? 'EnabledWithSymbolsInReceiver'

package/packages/dd-trace/src/datastreams/context.js

@@ -3,15 +3,17 @@
 const { storage } = require('../../../datadog-core')
 const log = require('../log')
 
+const legacyStorage = storage('legacy')
+
 function getDataStreamsContext () {
-  const store = storage('legacy').getStore()
+  const store = legacyStorage.getStore()
   return (store && store.dataStreamsContext) || null
 }
 
 function setDataStreamsContext (dataStreamsContext) {
   log.debug('Setting new DSM Context: %j.', dataStreamsContext)
 
-  if (dataStreamsContext) storage('legacy').enterWith({ ...(storage('legacy').getStore()), dataStreamsContext })
+  if (dataStreamsContext) legacyStorage.enterWith({ ...legacyStorage.getStore(), dataStreamsContext })
 }
 
 module.exports = {