dd-trace 5.96.0 → 5.98.0

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

@@ -22,19 +22,44 @@ let patchedRequire = null
 const moduleLoadStartChannel = dc.channel('dd-trace:moduleLoadStart')
 const moduleLoadEndChannel = dc.channel('dd-trace:moduleLoadEnd')
 
+function stripNodePrefix (name) {
+  if (typeof name !== 'string') return name
+  return name.startsWith('node:') ? name.slice(5) : name
+}
+
+const builtinModules = new Set(Module.builtinModules.map(stripNodePrefix))
+
+function isBuiltinModuleName (name) {
+  if (typeof name !== 'string') return false
+  return builtinModules.has(stripNodePrefix(name))
+}
+
+function normalizeModuleName (name) {
+  if (typeof name !== 'string') return name
+  const stripped = stripNodePrefix(name)
+  return builtinModules.has(stripped) ? stripped : name
+}
+
+/**
+ * @overload
+ * @param {string[]} modules list of modules to hook into
+ * @param {object} options hook options
+ * @param {Function} onrequire callback to be executed upon encountering module
+ */
+/**
+ * @overload
+ * @param {string[]} modules list of modules to hook into
+ * @param {Function} onrequire callback to be executed upon encountering module
+ */
 function Hook (modules, options, onrequire) {
   if (!(this instanceof Hook)) return new Hook(modules, options, onrequire)
-  if (typeof modules === 'function') {
-    onrequire = modules
-    modules = null
-    options = {}
-  } else if (typeof options === 'function') {
+  if (typeof options === 'function') {
     onrequire = options
     options = {}
   }
 
-  modules = modules || []
-  options = options || {}
+  modules ??= []
+  options ??= {}
 
   this.modules = modules
   this.options = options
@@ -63,32 +88,34 @@ function Hook (modules, options, onrequire) {
     */
     let filename
     try {
-      // @ts-expect-error Module._resolveFilename is not typed
+      // @ts-expect-error - Module._resolveFilename is not typed
       filename = Module._resolveFilename(request, this)
     } catch {
       return _origRequire.apply(this, arguments)
     }
-    const core = !filename.includes(path.sep)
+
+    const builtin = isBuiltinModuleName(filename)
+    const moduleId = builtin ? normalizeModuleName(filename) : filename
     let name, basedir, hooks
     // return known patched modules immediately
-    if (cache[filename]) {
-      const externalCacheEntry = require.cache[filename]
+    if (cache[moduleId]) {
       // require.cache was potentially altered externally
-      if (externalCacheEntry && externalCacheEntry.exports !== cache[filename].original) {
-        return externalCacheEntry.exports
+      const cacheEntry = require.cache[filename]
+      if (cacheEntry && cacheEntry.exports !== cache[filename].original) {
+        return cacheEntry.exports
       }
 
-      return cache[filename].exports
+      return cache[moduleId].exports
     }
 
     // Check if this module has a patcher in-progress already.
     // Otherwise, mark this module as patching in-progress.
-    const patched = patching[filename]
+    const patched = patching[moduleId]
     if (patched) {
       // If it's already patched, just return it as-is.
       return origRequire.apply(this, arguments)
     }
-    patching[filename] = true
+    patching[moduleId] = true
 
     const payload = {
       filename,
@@ -107,12 +134,12 @@ function Hook (modules, options, onrequire) {
 
     // The module has already been loaded,
     // so the patching mark can be cleaned up.
-    delete patching[filename]
+    delete patching[moduleId]
 
-    if (core) {
-      hooks = moduleHooks[filename]
+    if (builtin) {
+      hooks = moduleHooks[moduleId]
       if (!hooks) return exports // abort if module name isn't on whitelist
-      name = filename
+      name = moduleId
     } else {
       const inAWSLambda = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined
       const hasLambdaHandler = getValueFromEnvSources('DD_LAMBDA_HANDLER') !== undefined
@@ -129,7 +156,8 @@ function Hook (modules, options, onrequire) {
         hooks = moduleHooks[name]
         if (!hooks) return exports // abort if module name isn't on whitelist
 
-        // @ts-expect-error Module._resolveLookupPaths is not typed
+        // figure out if this is the main module file, or a file inside the module
+        // @ts-expect-error - Module._resolveLookupPaths is meant to be internal and is not typed
         const paths = Module._resolveLookupPaths(name, this, true)
         if (!paths) {
           // abort if _resolveLookupPaths return null
@@ -138,7 +166,7 @@ function Hook (modules, options, onrequire) {
 
         let res
         try {
-          // @ts-expect-error Module._findPath is not typed
+          // @ts-expect-error - Module._findPath is meant to be internal and is not typed
           res = Module._findPath(name, [basedir, ...paths])
         } catch {
           // case where the file specified in package.json "main" doesn't exist
@@ -163,17 +191,21 @@ function Hook (modules, options, onrequire) {
 
     // ensure that the cache entry is assigned a value before calling
     // onrequire, in case calling onrequire requires the same module.
-    cache[filename] = { exports }
-    cache[filename].original = exports
+    cache[moduleId] = { exports }
+    cache[moduleId].original = exports
 
     for (const hook of hooks) {
-      cache[filename].exports = hook(cache[filename].exports, name, basedir)
+      cache[moduleId].exports = hook(cache[moduleId].exports, name, basedir)
     }
 
-    return cache[filename].exports
+    return cache[moduleId].exports
   }
 }
 
+/**
+ * Reset the Ritm hook. This is used to reset the hook after a test.
+ * TODO: Remove this and instead use proxyquire to reset the hook.
+ */
 Hook.reset = function () {
   Module.prototype.require = origRequire
   patchedRequire = null

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

@@ -14,6 +14,9 @@ const noop = runtimeMetrics = {
 }
 
 module.exports = {
+  /**
+   * @param {import('../config/config-base')} config - Tracer configuration
+   */
   start (config) {
     if (!config?.runtimeMetrics.enabled) return
 

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

@@ -35,6 +35,9 @@ let eventLoopDelayObserver = null
 // https://github.com/DataDog/dogweb/blob/prod/integration/node/node_metadata.csv
 
 module.exports = {
+  /**
+   * @param {import('../config/config-base')} config - Tracer configuration
+   */
   start (config) {
     this.stop()
     const clientConfig = DogStatsDClient.generateClientConfig(config)
@@ -52,17 +55,21 @@ module.exports = {
       startGCObserver()
     }
 
-    // Using no-gc prevents the native gc metrics from being tracked. Not
-    // passing any options means all metrics are tracked.
-    // TODO: This is a workaround. We should find a better solution.
-    const watchers = trackEventLoop ? ['loop'] : ['no-gc']
-
-    try {
-      nativeMetrics = require('@datadog/native-metrics')
-      nativeMetrics.start(...watchers)
-    } catch (error) {
-      log.error('Error starting native metrics', error)
-      nativeMetrics = null
+    const useNative = config.runtimeMetrics.native !== false
+
+    if (useNative) {
+      // Using no-gc prevents the native gc metrics from being tracked. Not
+      // passing any options means all metrics are tracked.
+      // TODO: This is a workaround. We should find a better solution.
+      const watchers = trackEventLoop ? ['loop'] : ['no-gc']
+
+      try {
+        nativeMetrics = require('@datadog/native-metrics')
+        nativeMetrics.start(...watchers)
+      } catch (error) {
+        log.error('Error starting native metrics', error)
+        nativeMetrics = null
+      }
     }
 
     client = new MetricsAggregationClient(new DogStatsDClient(clientConfig))

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

@@ -42,7 +42,7 @@ class Sampler {
   /**
    * Determines whether a trace/span should be sampled based on the configured sampling rate.
    *
-   * @param {Span|SpanContext} span - The span or span context to evaluate.
+   * @param {import("../../..").Span|import("../../..").SpanContext} span - The span or span context to evaluate.
    * @returns {boolean} `true` if the trace/span should be sampled, otherwise `false`.
    */
   isSampled (span) {

package/packages/dd-trace/src/service-naming/index.js

@@ -41,7 +41,7 @@ class SchemaManager {
    * @param {string} kind
    * @param {string} plugin
    * @param {object} opts
-   * @returns {string}
+   * @returns {object} {name, source}
    */
   serviceName (type, kind, plugin, opts) {
     const schema = this.shouldUseConsistentServiceNaming

package/packages/dd-trace/src/service-naming/schemas/definition.js

@@ -12,7 +12,10 @@ class SchemaDefinition {
 
   getServiceName (type, kind, plugin, opts) {
     const item = this.schema[type][kind][plugin]
-    return item.serviceName(opts)
+    return {
+      name: item.serviceName(opts),
+      source: item.serviceSource?.(opts),
+    }
   }
 }
 

package/packages/dd-trace/src/service-naming/schemas/util.js

@@ -18,8 +18,22 @@ function httpPluginClientService ({ tracerService, pluginConfig, sessionDetails
   return tracerService
 }
 
+function optionServiceSource ({ pluginConfig }) {
+  if (pluginConfig.splitByDomain) {
+    return 'opt.split_by_domain'
+  }
+
+  if (pluginConfig.service) {
+    return 'opt.plugin'
+  }
+}
+
 function awsServiceV0 ({ tracerService, awsService }) {
   return `${tracerService}-aws-${awsService}`
 }
 
-module.exports = { identityService, httpPluginClientService, awsServiceV0 }
+function awsServiceSource ({ awsService }) {
+  return awsService
+}
+
+module.exports = { identityService, httpPluginClientService, awsServiceV0, optionServiceSource, awsServiceSource }

package/packages/dd-trace/src/service-naming/schemas/v0/messaging.js

@@ -1,66 +1,83 @@
 'use strict'
 
-const { identityService, awsServiceV0 } = require('../util')
+const { identityService, awsServiceV0, awsServiceSource } = require('../util')
 
 function amqpServiceName ({ tracerService }) {
   return `${tracerService}-amqp`
 }
 
+function integrationSource (source) {
+  return () => source
+}
+
 const messaging = {
   producer: {
     amqplib: {
       opName: () => 'amqp.command',
       serviceName: amqpServiceName,
+      serviceSource: integrationSource('amqp'),
     },
     amqp10: {
       opName: () => 'amqp.send',
       serviceName: amqpServiceName,
+      serviceSource: integrationSource('amqp'),
     },
     'azure-event-hubs': {
       opName: () => 'azure.eventhubs.send',
       serviceName: ({ tracerService }) => `${tracerService}-azure-event-hubs`,
+      serviceSource: integrationSource('azure-event-hubs'),
     },
     'azure-service-bus': {
       opName: () => 'azure.servicebus.send',
       serviceName: ({ tracerService }) => `${tracerService}-azure-service-bus`,
+      serviceSource: integrationSource('azure-service-bus'),
     },
     'google-cloud-pubsub': {
       opName: () => 'pubsub.request',
       serviceName: ({ tracerService }) => `${tracerService}-pubsub`,
+      serviceSource: integrationSource('google-cloud-pubsub'),
     },
     kafkajs: {
       opName: () => 'kafka.produce',
       serviceName: ({ tracerService }) => `${tracerService}-kafka`,
+      serviceSource: integrationSource('kafka'),
     },
     'confluentinc-kafka-javascript': {
       opName: () => 'kafka.produce',
       serviceName: ({ tracerService }) => `${tracerService}-kafka`,
+      serviceSource: integrationSource('kafka'),
     },
     rhea: {
       opName: () => 'amqp.send',
       serviceName: ({ tracerService }) => `${tracerService}-amqp-producer`,
+      serviceSource: integrationSource('amqp'),
     },
     sqs: {
       opName: () => 'aws.request',
       serviceName: awsServiceV0,
+      serviceSource: awsServiceSource,
     },
     sns: {
       opName: () => 'aws.request',
       serviceName: awsServiceV0,
+      serviceSource: awsServiceSource,
     },
     bullmq: {
       opName: () => 'bullmq.add',
       serviceName: ({ tracerService }) => `${tracerService}-bullmq`,
+      serviceSource: integrationSource('bullmq'),
     },
   },
   consumer: {
     amqplib: {
       opName: () => 'amqp.command',
       serviceName: amqpServiceName,
+      serviceSource: integrationSource('amqp'),
     },
     amqp10: {
       opName: () => 'amqp.receive',
       serviceName: amqpServiceName,
+      serviceSource: integrationSource('amqp'),
     },
     'google-cloud-pubsub': {
       opName: () => 'pubsub.receive',
@@ -69,10 +86,12 @@ const messaging = {
     kafkajs: {
       opName: () => 'kafka.consume',
       serviceName: ({ tracerService }) => `${tracerService}-kafka`,
+      serviceSource: integrationSource('kafka'),
     },
     'confluentinc-kafka-javascript': {
       opName: () => 'kafka.consume',
       serviceName: ({ tracerService }) => `${tracerService}-kafka`,
+      serviceSource: integrationSource('kafka'),
     },
     rhea: {
       opName: () => 'amqp.receive',
@@ -81,20 +100,24 @@ const messaging = {
     sqs: {
       opName: () => 'aws.request',
       serviceName: awsServiceV0,
+      serviceSource: awsServiceSource,
     },
     bullmq: {
       opName: () => 'bullmq.processJob',
       serviceName: ({ tracerService }) => `${tracerService}-bullmq`,
+      serviceSource: integrationSource('bullmq'),
     },
   },
   client: {
     amqplib: {
       opName: () => 'amqp.command',
       serviceName: amqpServiceName,
+      serviceSource: integrationSource('amqp'),
     },
     'google-cloud-pubsub': {
       opName: () => 'pubsub.request',
       serviceName: ({ tracerService }) => `${tracerService}-pubsub`,
+      serviceSource: integrationSource('google-cloud-pubsub'),
     },
   },
 }

package/packages/dd-trace/src/service-naming/schemas/v0/storage.js

@@ -30,11 +30,26 @@ function withSuffixFunction (suffix) {
   }
 }
 
+function optionServiceSource ({ pluginConfig, integration, connectionName }) {
+  if (pluginConfig.splitByInstance && connectionName) {
+    return 'opt.split_by_instance'
+  }
+
+  if (pluginConfig.service) {
+    return 'opt.plugin'
+  }
+
+  return integration
+}
+
 const redisConfig = {
   opName: () => 'redis.command',
   serviceName: ({ tracerService, pluginConfig, system, connectionName }) => {
     return getRedisService(pluginConfig, connectionName) || fromSystem(tracerService, system)
   },
+  serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+    return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'redis' })
+  },
 }
 
 const valkeyConfig = {
@@ -42,6 +57,9 @@ const valkeyConfig = {
   serviceName: ({ tracerService, pluginConfig, system, connectionName }) => {
     return getRedisService(pluginConfig, connectionName) || fromSystem(tracerService, system)
   },
+  serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+    return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'valkey' })
+  },
 }
 
 const storage = {
@@ -50,67 +68,109 @@ const storage = {
       opName: () => 'aerospike.command',
       serviceName: ({ tracerService, pluginConfig }) =>
         pluginConfig.service || `${tracerService}-aerospike`,
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'aerospike' })
+      },
     },
     'cassandra-driver': {
       opName: () => 'cassandra.query',
       serviceName: ({ tracerService, pluginConfig, system }) =>
         pluginConfig.service || fromSystem(tracerService, system),
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'cassandra-driver' })
+      },
     },
     couchbase: {
       opName: ({ operation }) => `couchbase.${operation}`,
       serviceName: ({ tracerService, pluginConfig }) => pluginConfig.service || `${tracerService}-couchbase`,
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'couchbase' })
+      },
     },
     elasticsearch: {
       opName: () => 'elasticsearch.query',
       serviceName: ({ tracerService, pluginConfig }) =>
         pluginConfig.service || `${tracerService}-elasticsearch`,
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'elasticsearch' })
+      },
     },
     ioredis: redisConfig,
     iovalkey: valkeyConfig,
     mariadb: {
       opName: () => 'mariadb.query',
       serviceName: mysqlServiceName,
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'mysql' })
+      },
     },
     memcached: {
       opName: () => 'memcached.command',
       serviceName: ({ tracerService, pluginConfig, system }) =>
         pluginConfig.service || fromSystem(tracerService, system),
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'memcached' })
+      },
     },
     'mongodb-core': {
       opName: () => 'mongodb.query',
       serviceName: ({ tracerService, pluginConfig }) =>
         pluginConfig.service || `${tracerService}-mongodb`,
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'mongodb' })
+      },
     },
     mysql: {
       opName: () => 'mysql.query',
       serviceName: mysqlServiceName,
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'mysql' })
+      },
     },
     mysql2: {
       opName: () => 'mysql.query',
       serviceName: mysqlServiceName,
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'mysql' })
+      },
     },
     opensearch: {
       opName: () => 'opensearch.query',
       serviceName: ({ tracerService, pluginConfig }) =>
         pluginConfig.service || `${tracerService}-opensearch`,
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'opensearch' })
+      },
     },
     oracledb: {
       opName: () => 'oracle.query',
       serviceName: withSuffixFunction('oracle'),
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'oracledb' })
+      },
     },
     pg: {
       opName: () => 'pg.query',
       serviceName: withSuffixFunction('postgres'),
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'pg' })
+      },
     },
     prisma: {
       opName: ({ operation }) => `prisma.${operation}`,
       serviceName: withSuffixFunction('prisma'),
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'prisma' })
+      },
     },
     redis: redisConfig,
     tedious: {
       opName: () => 'tedious.request',
       serviceName: ({ tracerService, pluginConfig, system }) =>
         pluginConfig.service || fromSystem(tracerService, system),
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'tedious' })
+      },
     },
   },
 }

package/packages/dd-trace/src/service-naming/schemas/v0/web.js

@@ -1,6 +1,9 @@
 'use strict'
 
-const { identityService, httpPluginClientService, awsServiceV0 } = require('../util')
+const {
+  identityService, httpPluginClientService, awsServiceV0,
+  optionServiceSource, awsServiceSource,
+} = require('../util')
 
 const web = {
   client: {
@@ -15,56 +18,69 @@ const web = {
     http: {
       opName: () => 'http.request',
       serviceName: httpPluginClientService,
+      serviceSource: optionServiceSource,
     },
     fetch: {
       opName: () => 'http.request',
       serviceName: httpPluginClientService,
+      serviceSource: optionServiceSource,
     },
     http2: {
       opName: () => 'http.request',
       serviceName: httpPluginClientService,
+      serviceSource: optionServiceSource,
     },
     genai: {
       opName: () => 'google_genai.request',
       serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService,
+      serviceSource: optionServiceSource,
     },
     aws: {
       opName: () => 'aws.request',
       serviceName: awsServiceV0,
+      serviceSource: awsServiceSource,
     },
     lambda: {
       opName: () => 'aws.request',
       serviceName: awsServiceV0,
+      serviceSource: awsServiceSource,
     },
     undici: {
       opName: () => 'undici.request',
       serviceName: httpPluginClientService,
+      serviceSource: optionServiceSource,
     },
   },
   server: {
     'apollo.gateway.request': {
       opName: () => 'apollo.gateway.request',
       serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService,
+      serviceSource: optionServiceSource,
     },
     'apollo.gateway.plan': {
       opName: () => 'apollo.gateway.plan',
       serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService,
+      serviceSource: optionServiceSource,
     },
     'apollo.gateway.validate': {
       opName: () => 'apollo.gateway.validate',
       serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService,
+      serviceSource: optionServiceSource,
     },
     'apollo.gateway.execute': {
       opName: () => 'apollo.gateway.execute',
       serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService,
+      serviceSource: optionServiceSource,
     },
     'apollo.gateway.fetch': {
       opName: () => 'apollo.gateway.fetch',
       serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService,
+      serviceSource: optionServiceSource,
     },
     'apollo.gateway.postprocessing': {
       opName: () => 'apollo.gateway.postprocessing',
       serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService,
+      serviceSource: optionServiceSource,
     },
     grpc: {
       opName: () => 'grpc.server',

package/packages/dd-trace/src/service-naming/schemas/v0/websocket.js

@@ -1,28 +1,33 @@
 'use strict'
+const { optionServiceSource } = require('../util')
 
 const websocket = {
   request: {
     ws: {
       opName: () => 'web.request',
       serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService,
+      serviceSource: optionServiceSource,
     },
   },
   producer: {
     ws: {
       opName: () => 'websocket.send',
       serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService,
+      serviceSource: optionServiceSource,
     },
   },
   consumer: {
     ws: {
       opName: () => 'websocket.receive',
       serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService,
+      serviceSource: optionServiceSource,
     },
   },
   close: {
     ws: {
       opName: () => 'websocket.close',
       serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService,
+      serviceSource: optionServiceSource,
     },
   },
 }