@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,54 @@
+'use strict'
+
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const { getAmqpMessageSize, DsmPathwayCodec } = require('../../dd-trace/src/datastreams')
+
+class RheaProducerPlugin extends ProducerPlugin {
+  static id = 'rhea'
+  static operation = 'send'
+
+  constructor (...args) {
+    super(...args)
+    this.addTraceSub('encode', this.encode.bind(this))
+  }
+
+  bindStart (ctx) {
+    const { targetAddress, host, port } = ctx
+    const name = targetAddress || 'amq.topic'
+    this.startSpan({
+      resource: name,
+      meta: {
+        component: 'rhea',
+        'amqp.link.target.address': name,
+        'amqp.link.role': 'sender',
+        'out.host': host,
+        [CLIENT_PORT_KEY]: port,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  encode (msg) {
+    addDeliveryAnnotations(msg, this.tracer, this.activeSpan)
+  }
+}
+
+function addDeliveryAnnotations (msg, tracer, span) {
+  if (msg) {
+    msg.delivery_annotations = msg.delivery_annotations || {}
+
+    tracer.inject(span, 'text_map', msg.delivery_annotations)
+
+    if (tracer._config.dsmEnabled) {
+      const targetName = span.context()._tags['amqp.link.target.address']
+      const payloadSize = getAmqpMessageSize({ content: msg.body, headers: msg.delivery_annotations })
+      const dataStreamsContext = tracer
+        .setCheckpoint(['direction:out', `exchange:${targetName}`, 'type:rabbitmq'], span, payloadSize)
+      DsmPathwayCodec.encode(dataStreamsContext, msg.delivery_annotations)
+    }
+  }
+}
+
+module.exports = RheaProducerPlugin

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

@@ -0,0 +1,170 @@
+'use strict'
+
+const web = require('../../dd-trace/src/plugins/util/web')
+const WebPlugin = require('../../datadog-plugin-web/src')
+const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const { storage } = require('../../datadog-core')
+const { COMPONENT } = require('../../dd-trace/src/constants')
+
+class RouterPlugin extends WebPlugin {
+  static id = 'router'
+
+  #storeStacks = new WeakMap()
+  #contexts = new WeakMap()
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub(`apm:${this.constructor.id}:middleware:enter`, ({ req, name, route }) => {
+      const childOf = this.#getActive(req) || this.#getStoreSpan()
+
+      if (!childOf) return
+
+      const span = this.#getMiddlewareSpan(name, childOf)
+      const context = this.#createContext(req, route, childOf)
+
+      if (childOf !== span) {
+        context.middleware.push(span)
+      }
+
+      const store = storage('legacy').getStore()
+      let storeStack = this.#storeStacks.get(req)
+      if (!storeStack) {
+        storeStack = []
+        this.#storeStacks.set(req, storeStack)
+      }
+      storeStack.push(store)
+      this.enter(span, store)
+
+      web.patch(req)
+      web.setRoute(req, context.route)
+    })
+
+    this.addSub(`apm:${this.constructor.id}:middleware:next`, ({ req }) => {
+      const context = this.#contexts.get(req)
+
+      if (!context) return
+
+      context.stack.pop()
+    })
+
+    this.addSub(`apm:${this.constructor.id}:middleware:finish`, ({ req }) => {
+      const context = this.#contexts.get(req)
+
+      if (!context || context.middleware.length === 0) return
+
+      context.middleware.pop().finish()
+    })
+
+    this.addSub(`apm:${this.constructor.id}:middleware:exit`, ({ req }) => {
+      const storeStack = this.#storeStacks.get(req)
+      const savedStore = storeStack && storeStack.pop()
+      if (storeStack && storeStack.length === 0) {
+        this.#storeStacks.delete(req)
+      }
+      const span = savedStore && savedStore.span
+      this.enter(span, savedStore)
+    })
+
+    this.addSub(`apm:${this.constructor.id}:middleware:error`, ({ req, error }) => {
+      web.addError(req, error)
+
+      if (!this.config.middleware) return
+
+      const span = this.#getActive(req)
+
+      if (!span) return
+
+      span.setTag('error', error)
+    })
+
+    this.addSub('apm:http:server:request:finish', ({ req }) => {
+      const context = this.#contexts.get(req)
+
+      if (!context) return
+
+      let span
+
+      while ((span = context.middleware.pop())) {
+        span.finish()
+      }
+    })
+  }
+
+  #getActive (req) {
+    const context = this.#contexts.get(req)
+
+    if (!context) return
+    if (context.middleware.length === 0) return context.span
+
+    return context.middleware.at(-1)
+  }
+
+  #getStoreSpan () {
+    const store = storage('legacy').getStore()
+
+    return store && store.span
+  }
+
+  #getMiddlewareSpan (name, childOf) {
+    if (this.config.middleware === false) {
+      return childOf
+    }
+
+    const span = this.tracer.startSpan(`${this.constructor.id}.middleware`, {
+      childOf,
+      integrationName: this.constructor.id,
+      tags: {
+        [COMPONENT]: this.constructor.id,
+        'resource.name': name || '<anonymous>',
+      },
+    })
+
+    analyticsSampler.sample(span, this.config.measured)
+
+    return span
+  }
+
+  #createContext (req, route, span) {
+    let context = this.#contexts.get(req)
+
+    if (!route || route === '/' || route === '*') {
+      route = ''
+    }
+
+    if (context) {
+      context.stack.push(route)
+
+      route = context.stack.join('')
+
+      // Longer route is more likely to be the actual route handler route.
+      if (isMoreSpecificThan(route, context.route)) {
+        context.route = route
+      }
+    } else {
+      context = {
+        span,
+        stack: [route],
+        route,
+        middleware: [],
+      }
+
+      this.#contexts.set(req, context)
+    }
+
+    return context
+  }
+}
+
+function isMoreSpecificThan (routeA, routeB) {
+  if (!routeIsRegex(routeA) && routeIsRegex(routeB)) {
+    return true
+  }
+  return routeA.length > routeB.length
+}
+
+function routeIsRegex (route) {
+  return route.includes('(/')
+}
+
+module.exports = RouterPlugin

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

@@ -0,0 +1,66 @@
+'use strict'
+
+const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
+const { storage } = require('../../datadog-core')
+
+const {
+  TEST_IS_RUM_ACTIVE,
+  TEST_BROWSER_DRIVER,
+  TEST_BROWSER_DRIVER_VERSION,
+  TEST_BROWSER_NAME,
+  TEST_BROWSER_VERSION,
+  TEST_TYPE,
+} = require('../../dd-trace/src/plugins/util/test')
+const { SPAN_TYPE } = require('../../../ext/tags')
+
+function isTestSpan (span) {
+  return span.context()._tags[SPAN_TYPE] === 'test'
+}
+
+function getTestSpanFromTrace (trace) {
+  for (const span of trace.started) {
+    if (isTestSpan(span)) {
+      return span
+    }
+  }
+  return null
+}
+
+class SeleniumPlugin extends CiPlugin {
+  static id = 'selenium'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('ci:selenium:driver:get', ({
+      setTraceId,
+      seleniumVersion,
+      browserName,
+      browserVersion,
+      isRumActive,
+    }) => {
+      const store = storage('legacy').getStore()
+      const span = store?.span
+      if (!span) {
+        return
+      }
+      const testSpan = isTestSpan(span) ? span : getTestSpanFromTrace(span.context()._trace)
+      if (!testSpan) {
+        return
+      }
+      if (setTraceId) {
+        setTraceId(testSpan.context().toTraceId())
+      }
+      if (isRumActive) {
+        testSpan.setTag(TEST_IS_RUM_ACTIVE, 'true')
+      }
+      testSpan.setTag(TEST_BROWSER_DRIVER, 'selenium')
+      testSpan.setTag(TEST_BROWSER_DRIVER_VERSION, seleniumVersion)
+      testSpan.setTag(TEST_BROWSER_NAME, browserName)
+      testSpan.setTag(TEST_BROWSER_VERSION, browserVersion)
+      testSpan.setTag(TEST_TYPE, 'browser')
+    })
+  }
+}
+
+module.exports = SeleniumPlugin

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

@@ -0,0 +1,68 @@
+'use strict'
+
+const ServerPlugin = require('../../dd-trace/src/plugins/server')
+
+class SharedbPlugin extends ServerPlugin {
+  static id = 'sharedb'
+
+  bindStart (ctx) {
+    const { actionName, request } = ctx
+
+    const span = this.startSpan('sharedb.request', {
+      service: this.config.service,
+      resource: getReadableResourceName(actionName, request.c, request.q),
+      kind: 'server',
+      meta: {
+        'sharedb.action': actionName,
+      },
+    }, ctx)
+
+    if (this.config.hooks && this.config.hooks.receive) {
+      this.config.hooks.receive(span, request)
+    }
+
+    return ctx.currentStore
+  }
+
+  bindFinish (ctx) {
+    const { request, res } = ctx
+
+    const span = ctx.currentStore.span
+    if (this.config.hooks && this.config.hooks.reply) {
+      this.config.hooks.reply(span, request, res)
+    }
+    super.finish(ctx)
+
+    return ctx.parentStore
+  }
+}
+
+function getReadableResourceName (readableActionName, collection, query) {
+  if (collection) {
+    readableActionName += ' ' + collection
+  }
+  if (query) {
+    readableActionName += ' ' + JSON.stringify(sanitize(query))
+  }
+  return readableActionName
+}
+
+function sanitize (input) {
+  const output = {}
+
+  if (!isObject(input) || Buffer.isBuffer(input)) return '?'
+
+  for (const key in input) {
+    if (typeof input[key] === 'function') continue
+
+    output[key] = sanitize(input[key])
+  }
+
+  return output
+}
+
+function isObject (val) {
+  return val !== null && typeof val === 'object' && !Array.isArray(val)
+}
+
+module.exports = SharedbPlugin

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

@@ -0,0 +1,36 @@
+'use strict'
+
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+
+class TediousPlugin extends DatabasePlugin {
+  static id = 'tedious'
+  static operation = 'request' // TODO: change to match other database plugins
+  static system = 'mssql'
+
+  bindStart (ctx) {
+    const service = this.serviceName({ pluginConfig: this.config, system: this.system })
+    const span = this.startSpan(this.operationName(), {
+      service,
+      resource: ctx.queryOrProcedure,
+      type: 'sql',
+      kind: 'client',
+      meta: {
+        'db.type': 'mssql',
+        component: 'tedious',
+        'out.host': ctx.connectionConfig.server,
+        [CLIENT_PORT_KEY]: ctx.connectionConfig.options.port,
+        'db.user': ctx.connectionConfig.userName || ctx.connectionConfig.authentication.options.userName,
+        'db.name': ctx.connectionConfig.options.database,
+        'db.instance': ctx.connectionConfig.options.instanceName,
+      },
+    }, ctx)
+
+    // SQL Server includes comments when caching queries
+    // For that reason we allow service mode but not full mode
+    ctx.sql = this.injectDbmQuery(span, ctx.queryOrProcedure, service, true)
+    return ctx.currentStore
+  }
+}
+
+module.exports = TediousPlugin

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

@@ -0,0 +1,313 @@
+'use strict'
+
+const HttpClientPlugin = require('../../datadog-plugin-http/src/client')
+const { storage } = require('../../datadog-core')
+const tags = require('../../../ext/tags')
+const formats = require('../../../ext/formats')
+const HTTP_HEADERS = formats.HTTP_HEADERS
+const log = require('../../dd-trace/src/log')
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
+
+const {
+  HTTP_STATUS_CODE,
+  HTTP_REQUEST_HEADERS,
+  HTTP_RESPONSE_HEADERS,
+} = tags
+
+// WeakMap to store span context for native undici request objects
+const requestContexts = new WeakMap()
+
+class UndiciPlugin extends HttpClientPlugin {
+  static id = 'undici'
+  static prefix = 'tracing:apm:undici:fetch'
+
+  constructor (...args) {
+    super(...args)
+
+    // 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:headers', this.#onNativeRequestHeaders.bind(this))
+    this.addSub('undici:request:trailers', this.#onNativeRequestTrailers.bind(this))
+    this.addSub('undici:request:error', this.#onNativeRequestError.bind(this))
+  }
+
+  // ===========================================
+  // Native undici diagnostic channel handlers
+  // These fire for undici >= 4.7.0 for ALL request types (fetch, request, stream, etc.)
+  // ===========================================
+
+  #onNativeRequestCreate ({ request }) {
+    if (!request) return
+
+    const store = storage('legacy').getStore()
+    const { origin = '', path = '/' } = request
+    const method = request.method?.toUpperCase() ?? 'GET'
+
+    // Parse origin to extract protocol, hostname, port
+    let protocol = 'http:'
+    let hostname = 'localhost'
+    let port = ''
+
+    try {
+      const url = new URL(origin)
+      protocol = url.protocol
+      hostname = url.hostname
+      port = url.port
+    } catch {
+      // If origin is not a valid URL, use defaults
+    }
+
+    const host = port ? `${hostname}:${port}` : hostname
+    const pathname = path.split(/[?#]/)[0]
+    const uri = `${protocol}//${host}${pathname}`
+
+    const allowed = this.config.filter(uri)
+    const childOf = store && allowed ? store.span : null
+
+    const span = this.startSpan(this.operationName(), {
+      childOf,
+      meta: {
+        'span.kind': 'client',
+        'http.method': method,
+        'http.url': uri,
+        'out.host': hostname,
+      },
+      metrics: {
+        [CLIENT_PORT_KEY]: port ? Number.parseInt(port, 10) : undefined,
+      },
+      service: this.serviceName({ pluginConfig: this.config, sessionDetails: { host: hostname, port } }),
+      resource: method,
+      type: 'http',
+    }, false)
+
+    // Disable recording if not allowed
+    if (!allowed) {
+      span._spanContext._trace.record = false
+    }
+
+    // Capture request headers if configured
+    if (request.headers && this.config.headers) {
+      addConfiguredHeaders(span, request.headers, this.config.headers, HTTP_REQUEST_HEADERS)
+    }
+
+    // Inject trace headers if propagation is allowed
+    if (this.config.propagationFilter(uri)) {
+      const headers = {}
+      this.tracer.inject(span, HTTP_HEADERS, headers)
+
+      // Use addHeader if available (undici provides this on the request object)
+      if (typeof request.addHeader === 'function') {
+        for (const [name, value] of Object.entries(headers)) {
+          request.addHeader(name, value)
+        }
+      }
+    }
+
+    // Store span context for request for later retrieval
+    requestContexts.set(request, {
+      span,
+      store,
+      uri,
+    })
+
+    // Enter the span context
+    storage('legacy').enterWith({ ...store, span })
+  }
+
+  #onNativeRequestHeaders ({ request, response }) {
+    const ctx = requestContexts.get(request)
+    if (!ctx) return
+
+    const { span } = ctx
+    const statusCode = response?.statusCode
+
+    if (statusCode) {
+      span.setTag(HTTP_STATUS_CODE, statusCode)
+
+      if (!this.config.validateStatus(statusCode)) {
+        span.setTag('error', 1)
+      }
+    }
+
+    // Add response headers if configured
+    if (response?.headers && this.config.headers) {
+      addConfiguredHeaders(span, response.headers, this.config.headers, HTTP_RESPONSE_HEADERS)
+    }
+  }
+
+  #onNativeRequestTrailers ({ request }) {
+    const ctx = requestContexts.get(request)
+    if (!ctx) return
+
+    const { span, store } = ctx
+
+    // Call the request hook if configured
+    this.config.hooks.request(span, null, null)
+
+    // Finish the span
+    span.finish()
+
+    // Clean up
+    requestContexts.delete(request)
+
+    // Restore parent store
+    if (store) {
+      storage('legacy').enterWith(store)
+    }
+  }
+
+  #onNativeRequestError ({ request, error }) {
+    const ctx = requestContexts.get(request)
+    if (!ctx) return
+
+    const { span, store } = ctx
+
+    // Don't record AbortError as an error - it's user-initiated cancellation
+    if (error && error.name !== 'AbortError') {
+      span.setTag('error', error)
+    }
+
+    // Call the request hook if configured
+    this.config.hooks.request(span, null, null)
+
+    // Finish the span
+    span.finish()
+
+    // Clean up
+    requestContexts.delete(request)
+
+    // Restore parent store
+    if (store) {
+      storage('legacy').enterWith(store)
+    }
+  }
+
+  // ===========================================
+  // Fetch-based tracing channel handlers
+  // These handle fetch() for undici < 4.7.0 (before native DC was added)
+  // ===========================================
+
+  bindStart (ctx) {
+    const req = ctx.req
+    const options = new URL(req.url)
+    options.headers = Object.fromEntries(req.headers.entries())
+    options.method = req.method
+
+    ctx.args = { options }
+
+    const store = super.bindStart(ctx)
+
+    // Inject trace headers back into the request
+    for (const name of Object.keys(options.headers)) {
+      if (!req.headers.has(name)) {
+        req.headers.set(name, options.headers[name])
+      }
+    }
+
+    return store
+  }
+
+  error (ctx) {
+    // Don't record AbortError as an error - it's user-initiated cancellation
+    if (!ctx.error || ctx.error.name !== 'AbortError') {
+      return super.error(ctx)
+    }
+  }
+
+  asyncEnd (ctx) {
+    ctx.res = ctx.result
+    return this.finish(ctx)
+  }
+
+  configure (config) {
+    return super.configure(normalizeConfig(config))
+  }
+}
+
+// Add configured headers to span with appropriate tags
+function addConfiguredHeaders (span, rawHeaders, configuredHeaders, headerType) {
+  const headers = normalizeHeaders(rawHeaders)
+
+  for (const [key, tag] of configuredHeaders) {
+    const value = headers[key]
+    if (value) {
+      span.setTag(tag || `${headerType}.${key}`, value)
+    }
+  }
+}
+
+// Normalize headers to an object, handling different undici formats:
+// - Array format: alternating key-value pairs (undici >= 6.0.0)
+// - String format: HTTP header lines like "key: value\r\n" (undici 5.x)
+// - Object format: already a headers object
+function normalizeHeaders (headers) {
+  if (!headers) return {}
+
+  // String format (undici 5.x): "key: value\r\nkey2: value2\r\n"
+  if (typeof headers === 'string') {
+    const result = {}
+    const lines = headers.split('\r\n')
+    for (const line of lines) {
+      if (!line) continue
+      const colonIndex = line.indexOf(':')
+      if (colonIndex > 0) {
+        const key = line.slice(0, colonIndex).toLowerCase().trim()
+        const value = line.slice(colonIndex + 1).trim()
+        result[key] = value
+      }
+    }
+    return result
+  }
+
+  // Array format (undici >= 6.0.0): alternating key-value pairs
+  if (Array.isArray(headers)) {
+    const result = {}
+    for (let i = 0; i < headers.length; i += 2) {
+      const key = headers[i]
+      if (typeof key === 'string') {
+        result[key.toLowerCase()] = headers[i + 1]
+      } else if (Buffer.isBuffer(key)) {
+        result[key.toString().toLowerCase()] = headers[i + 1]?.toString?.() || headers[i + 1]
+      }
+    }
+    return result
+  }
+
+  // Object format: use as-is
+  return headers
+}
+
+function normalizeConfig (config) {
+  const validateStatus = getStatusValidator(config)
+  const hooks = getHooks(config)
+
+  return {
+    ...config,
+    validateStatus,
+    hooks,
+  }
+}
+
+function getStatusValidator (config) {
+  if (typeof config.validateStatus === 'function') {
+    return config.validateStatus
+  } else if (Object.hasOwn(config, 'validateStatus')) {
+    log.error('Expected `validateStatus` to be a function.')
+  }
+  return defaultValidateStatus
+}
+
+function defaultValidateStatus (code) {
+  return code < 400 || code >= 500
+}
+
+function getHooks (config) {
+  const request = config.hooks?.request ?? noop
+
+  return { request }
+}
+
+function noop () {}
+
+module.exports = UndiciPlugin