dd-trace 5.96.0 → 5.98.0

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const { optionServiceSource } = require('../util')
+
 function configWithFallback ({ tracerService, pluginConfig }) {
   return pluginConfig.service || tracerService
 }
@@ -7,11 +9,13 @@ function configWithFallback ({ tracerService, pluginConfig }) {
 const redisNaming = {
   opName: () => 'redis.command',
   serviceName: configWithFallback,
+  serviceSource: optionServiceSource,
 }
 
 const mySQLNaming = {
   opName: () => 'mysql.query',
   serviceName: withFunction,
+  serviceSource: optionServiceSource,
 }
 
 function withFunction ({ tracerService, pluginConfig, params }) {
@@ -27,58 +31,71 @@ const storage = {
     aerospike: {
       opName: () => 'aerospike.command',
       serviceName: configWithFallback,
+      serviceSource: optionServiceSource,
     },
     'cassandra-driver': {
       opName: () => 'cassandra.query',
       serviceName: configWithFallback,
+      serviceSource: optionServiceSource,
     },
     couchbase: {
       opName: () => 'couchbase.query',
       serviceName: configWithFallback,
+      serviceSource: optionServiceSource,
     },
     elasticsearch: {
       opName: () => 'elasticsearch.query',
       serviceName: configWithFallback,
+      serviceSource: optionServiceSource,
     },
     ioredis: redisNaming,
     iovalkey: {
       opName: () => 'valkey.command',
       serviceName: configWithFallback,
+      serviceSource: optionServiceSource,
     },
     mariadb: {
       opName: () => 'mariadb.query',
       serviceName: withFunction,
+      serviceSource: optionServiceSource,
     },
     memcached: {
       opName: () => 'memcached.command',
       serviceName: configWithFallback,
+      serviceSource: optionServiceSource,
     },
     'mongodb-core': {
       opName: () => 'mongodb.query',
       serviceName: configWithFallback,
+      serviceSource: optionServiceSource,
     },
     mysql: mySQLNaming,
     mysql2: mySQLNaming,
     opensearch: {
       opName: () => 'opensearch.query',
       serviceName: configWithFallback,
+      serviceSource: optionServiceSource,
     },
     oracledb: {
       opName: () => 'oracle.query',
       serviceName: withFunction,
+      serviceSource: optionServiceSource,
     },
     pg: {
       opName: () => 'postgresql.query',
       serviceName: withFunction,
+      serviceSource: optionServiceSource,
     },
     prisma: {
       opName: ({ operation }) => `prisma.${operation}`,
       serviceName: configWithFallback,
+      serviceSource: optionServiceSource,
     },
     redis: redisNaming,
     tedious: {
       opName: () => 'mssql.query',
       serviceName: configWithFallback,
+      serviceSource: optionServiceSource,
     },
   },
 }

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { identityService, httpPluginClientService } = require('../util')
+const { identityService, httpPluginClientService, optionServiceSource } = require('../util')
 
 const web = {
   client: {
@@ -15,18 +15,22 @@ const web = {
     http: {
       opName: () => 'http.client.request',
       serviceName: httpPluginClientService,
+      serviceSource: optionServiceSource,
     },
     genai: {
       opName: () => 'google_genai.request',
       serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService,
+      serviceSource: optionServiceSource,
     },
     fetch: {
       opName: () => 'http.client.request',
       serviceName: httpPluginClientService,
+      serviceSource: optionServiceSource,
     },
     http2: {
       opName: () => 'http.client.request',
       serviceName: httpPluginClientService,
+      serviceSource: optionServiceSource,
     },
     aws: {
       opName: ({ awsService }) => `aws.${awsService}.request`,
@@ -45,26 +49,32 @@ const web = {
     '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.request',

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

@@ -1,28 +1,34 @@
 '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,
     },
   },
 }

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

@@ -11,7 +11,7 @@ const {
   HTTP_ROUTE,
   HTTP_METHOD,
 } = require('../../../ext/tags')
-const { ORIGIN_KEY, TOP_LEVEL_KEY } = require('./constants')
+const { ORIGIN_KEY, TOP_LEVEL_KEY, SVC_SRC_KEY } = require('./constants')
 const { version } = require('./pkg')
 const processTags = require('./process-tags')
 
@@ -60,6 +60,7 @@ class SpanAggStats {
       synthetics,
       method,
       endpoint,
+      srvSrc,
     } = this.aggKey
 
     return {
@@ -71,6 +72,7 @@ class SpanAggStats {
       Synthetics: synthetics,
       HTTPMethod: method,
       HTTPEndpoint: endpoint,
+      srv_src: srvSrc,
       Hits: this.hits,
       TopLevelHits: this.topLevelHits,
       Errors: this.errors,
@@ -91,6 +93,7 @@ class SpanAggKey {
     this.synthetics = span.meta[ORIGIN_KEY] === 'synthetics'
     this.endpoint = span.meta[HTTP_ROUTE] || span.meta[HTTP_ENDPOINT] || ''
     this.method = span.meta[HTTP_METHOD] || ''
+    this.srvSrc = span.meta[SVC_SRC_KEY] || ''
   }
 
   toString () {
@@ -103,6 +106,7 @@ class SpanAggKey {
       this.synthetics,
       this.method,
       this.endpoint,
+      this.srvSrc,
     ].join(',')
   }
 }

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

@@ -11,6 +11,9 @@ const startCh = channel('dd-trace:span:start')
 const injectCh = channel('dd-trace:span:inject')
 const extractCh = channel('dd-trace:span:extract')
 
+/**
+ * @param {import('../config/config-base')} config - Tracer configuration
+ */
 function configure (config) {
   if (startCh.hasSubscribers) startCh.unsubscribe(onSpanStart)
   if (injectCh.hasSubscribers) injectCh.unsubscribe(onSpanInject)

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

@@ -5,15 +5,14 @@ let telemetry
 // Lazy load the telemetry module to avoid the performance impact of loading it unconditionally
 module.exports = {
   start (config, ...args) {
+    if (!config.telemetry.enabled) return
     telemetry ??= require('./telemetry')
     telemetry.start(config, ...args)
   },
-  stop () {
-    telemetry?.stop()
-  },
   // This might be called before `start` so we have to trigger loading the
   // underlying module here as well.
   updateConfig (changes, config, ...args) {
+    if (!config.telemetry.enabled) return
     telemetry ??= require('./telemetry')
     telemetry.updateConfig(changes, config, ...args)
   },

package/packages/dd-trace/src/telemetry/send-data.js

@@ -62,19 +62,6 @@ const { getValueFromEnvSources } = require('../config/helper')
  *   kernel_name?: string
  * } & Record<string, unknown>} TelemetryHost
  */
-/**
- * @typedef {{
- *   hostname?: string,
- *   port?: string | number,
- *   url?: string | URL,
- *   site?: string,
- *   apiKey?: string,
- *   isCiVisibility?: boolean,
- *   spanAttributeSchema?: string,
- *   tags: Record<string, string>,
- *   telemetry?: { debug?: boolean }
- * }} TelemetryConfig
- */
 /**
  * @callback SendDataCallback
  * @param {Error | null | undefined} error
@@ -85,23 +72,22 @@ const { getValueFromEnvSources } = require('../config/helper')
 let agentTelemetry = true
 
 /**
- * @param {TelemetryConfig} config
+ * @param {import('../config/config-base')} config
  * @param {TelemetryApplication} application
  * @param {TelemetryRequestType} reqType
  * @returns {Record<string, string>}
  */
 function getHeaders (config, application, reqType) {
-  const sessionId = config.tags['runtime-id']
   const headers = {
     'content-type': 'application/json',
     'dd-telemetry-api-version': 'v2',
     'dd-telemetry-request-type': reqType,
     'dd-client-library-language': application.language_name,
     'dd-client-library-version': application.tracer_version,
-    'dd-session-id': sessionId,
+    'dd-session-id': config.tags['runtime-id'],
   }
-  if (config.rootSessionId && config.rootSessionId !== sessionId) {
-    headers['dd-root-session-id'] = config.rootSessionId
+  if (config.DD_ROOT_JS_SESSION_ID) {
+    headers['dd-root-session-id'] = config.DD_ROOT_JS_SESSION_ID
   }
   const debug = config.telemetry && config.telemetry.debug
   if (debug) {
@@ -141,7 +127,7 @@ function getPayload (payload) {
 
 // TODO(BridgeAR): Simplify this code. A lot does not need to be recalculated on every call.
 /**
- * @param {TelemetryConfig} config
+ * @param {import('../config/config-base')} config
  * @param {TelemetryApplication} application
  * @param {TelemetryHost} host
  * @param {TelemetryRequestType} reqType

package/packages/dd-trace/src/telemetry/session-propagation.js

@@ -1,53 +1,37 @@
 'use strict'
 
-const dc = require('dc-polyfill')
-
+const dc = /** @type {typeof import('diagnostics_channel')} */ (require('dc-polyfill'))
 const childProcessChannel = dc.tracingChannel('datadog:child_process:execution')
 
 let subscribed = false
-let rootSessionId
 let runtimeId
 
-function injectSessionEnv (existingEnv) {
-  // eslint-disable-next-line eslint-rules/eslint-process-env -- not in supported-configurations.json
-  const base = existingEnv == null ? process.env : existingEnv
-  return {
-    ...base,
-    DD_ROOT_JS_SESSION_ID: rootSessionId,
-    DD_PARENT_JS_SESSION_ID: runtimeId,
-  }
+function isOptionsObject (value) {
+  return value != null && typeof value === 'object' && !Array.isArray(value) && value
 }
 
-function findOptionsIndex (args, shell) {
-  if (Array.isArray(args[1])) {
-    return { index: 2, exists: args[2] != null && typeof args[2] === 'object' }
-  }
-  if (args[1] != null && typeof args[1] === 'object') {
-    return { index: 1, exists: true }
-  }
-  if (!shell && args[2] != null && typeof args[2] === 'object') {
-    return { index: 2, exists: true }
-  }
-  return { index: shell ? 1 : 2, exists: false }
+function getEnvWithRuntimeId (env) {
+  // eslint-disable-next-line eslint-rules/eslint-process-env
+  return { ...(env ?? process.env), DD_ROOT_JS_SESSION_ID: runtimeId }
 }
 
 function onChildProcessStart (context) {
-  if (!context.callArgs) return
-
   const args = context.callArgs
-  const { index, exists } = findOptionsIndex(args, context.shell)
+  if (!args) return
 
-  if (exists) {
-    args[index] = { ...args[index], env: injectSessionEnv(args[index].env) }
+  const index = Array.isArray(args[1]) || (!context.shell && !isOptionsObject(args[1])) ? 2 : 1
+  const options = isOptionsObject(args[index]) ? args[index] : undefined
+
+  if (options) {
+    args[index] = { ...options, env: getEnvWithRuntimeId(options.env) }
     return
   }
 
-  const opts = { env: injectSessionEnv(null) }
-
-  if (!context.shell && !Array.isArray(args[1])) {
+  if (index === 2 && !Array.isArray(args[1])) {
     args.splice(1, 0, [])
   }
 
+  const opts = { env: getEnvWithRuntimeId() }
   if (typeof args[index] === 'function') {
     args.splice(index, 0, opts)
   } else {
@@ -55,24 +39,15 @@ function onChildProcessStart (context) {
   }
 }
 
-const handler = { start: onChildProcessStart }
-
 function start (config) {
   if (!config.telemetry?.enabled || subscribed) return
   subscribed = true
 
-  rootSessionId = config.rootSessionId
-  runtimeId = config.tags['runtime-id']
-
-  childProcessChannel.subscribe(handler)
-}
+  runtimeId = config.DD_ROOT_JS_SESSION_ID || config.tags['runtime-id']
 
-function stop () {
-  if (!subscribed) return
-  childProcessChannel.unsubscribe(handler)
-  subscribed = false
-  rootSessionId = undefined
-  runtimeId = undefined
+  childProcessChannel.subscribe(
+    /** @type {import('diagnostics_channel').TracingChannelSubscribers<object>} */ ({ start: onChildProcessStart })
+  )
 }
 
-module.exports = { start, stop, _onChildProcessStart: onChildProcessStart }
+module.exports = { start }