@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-plugin-dd-trace-api/src/index.js

@@ -0,0 +1,117 @@
+'use strict'
+
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const telemetryMetrics = require('../../dd-trace/src/telemetry/metrics')
+const apiMetrics = telemetryMetrics.manager.namespace('tracers')
+const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
+
+// api ==> here
+const objectMap = new WeakMap()
+
+const injectionEnabledTag =
+  `injection_enabled:${getValueFromEnvSources('DD_INJECTION_ENABLED') ? 'yes' : 'no'}`
+
+module.exports = class DdTraceApiPlugin extends Plugin {
+  static id = 'dd-trace-api'
+
+  constructor (...args) {
+    super(...args)
+
+    const tracer = this._tracer
+
+    this.addSub('datadog-api:v1:tracerinit', ({ proxy }) => {
+      const proxyVal = proxy()
+      objectMap.set(proxyVal, tracer)
+      objectMap.set(proxyVal.appsec, tracer.appsec)
+      objectMap.set(proxyVal.dogstatsd, tracer.dogstatsd)
+    })
+
+    const handleEvent = (name) => {
+      const counter = apiMetrics.count('public_api.called', [
+        `name:${name.replaceAll(':', '.')}`,
+        'api_version:v1',
+        injectionEnabledTag,
+      ])
+
+      // For v1, APIs are 1:1 with their internal equivalents, so we can just
+      // call the internal method directly. That's what we do here unless we
+      // want to override. As the API evolves, this may change.
+      this.addSub(`datadog-api:v1:${name}`, ({ self, args, ret, proxy, revProxy }) => {
+        counter.inc()
+
+        if (name.includes(':')) {
+          name = name.split(':').pop()
+        }
+
+        if (objectMap.has(self)) {
+          self = objectMap.get(self)
+        }
+
+        for (let i = 0; i < args.length; i++) {
+          if (objectMap.has(args[i])) {
+            args[i] = objectMap.get(args[i])
+          }
+          if (typeof args[i] === 'function') {
+            const orig = args[i]
+            args[i] = (...fnArgs) => {
+              for (let j = 0; j < fnArgs.length; j++) {
+                if (revProxy && revProxy[j]) {
+                  const proxyVal = revProxy[j]()
+                  objectMap.set(proxyVal, fnArgs[j])
+                  fnArgs[j] = proxyVal
+                }
+              }
+              // TODO do we need to apply(this, ...) here?
+              return orig(...fnArgs)
+            }
+          }
+        }
+
+        try {
+          ret.value = self[name](...args)
+          if (proxy) {
+            const proxyVal = proxy()
+            objectMap.set(proxyVal, ret.value)
+            ret.value = proxyVal
+          }
+        } catch (e) {
+          ret.error = e
+        }
+      })
+    }
+
+    // handleEvent('configure')
+    handleEvent('startSpan')
+    handleEvent('wrap')
+    handleEvent('trace')
+    handleEvent('inject')
+    handleEvent('extract')
+    handleEvent('getRumData')
+    handleEvent('profilerStarted')
+    handleEvent('context:toTraceId')
+    handleEvent('context:toSpanId')
+    handleEvent('context:toTraceparent')
+    handleEvent('span:context')
+    handleEvent('span:setTag')
+    handleEvent('span:addTags')
+    handleEvent('span:finish')
+    handleEvent('span:addLink')
+    handleEvent('scope')
+    handleEvent('scope:activate')
+    handleEvent('scope:active')
+    handleEvent('scope:bind')
+    handleEvent('appsec:blockRequest')
+    handleEvent('appsec:isUserBlocked')
+    handleEvent('appsec:setUser')
+    handleEvent('appsec:trackCustomEvent')
+    handleEvent('appsec:trackUserLoginFailureEvent')
+    handleEvent('appsec:trackUserLoginSuccessEvent')
+    handleEvent('dogstatsd:decrement')
+    handleEvent('dogstatsd:distribution')
+    handleEvent('dogstatsd:flush')
+    handleEvent('dogstatsd:gauge')
+    handleEvent('dogstatsd:histogram')
+    handleEvent('dogstatsd:increment')
+    handleEvent('use')
+  }
+}

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

@@ -0,0 +1,23 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const DNSLookupPlugin = require('./lookup')
+const DNSLookupServicePlugin = require('./lookup_service')
+const DNSResolvePlugin = require('./resolve')
+const DNSReversePlugin = require('./reverse')
+
+// TODO: Are DNS spans really client spans?
+
+class DNSPlugin extends CompositePlugin {
+  static id = 'dns'
+  static get plugins () {
+    return {
+      lookup: DNSLookupPlugin,
+      lookup_service: DNSLookupServicePlugin,
+      resolve: DNSResolvePlugin,
+      reverse: DNSReversePlugin,
+    }
+  }
+}
+
+module.exports = DNSPlugin

package/packages/datadog-plugin-dns/src/lookup.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+
+class DNSLookupPlugin extends ClientPlugin {
+  static id = 'dns'
+  static operation = 'lookup'
+
+  bindStart (ctx) {
+    const [hostname] = ctx.args
+
+    this.startSpan('dns.lookup', {
+      service: this.config.service,
+      resource: hostname,
+      kind: 'client',
+      meta: {
+        'dns.hostname': hostname,
+        'dns.address': '',
+        'dns.addresses': '',
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  bindFinish (ctx) {
+    const span = ctx.currentStore.span
+    const result = ctx.result
+
+    if (Array.isArray(result)) {
+      const addresses = Array.isArray(result)
+        ? result.map(address => address.address).sort()
+        : [result]
+
+      span.setTag('dns.address', addresses[0])
+      span.setTag('dns.addresses', addresses.join(','))
+    } else {
+      span.setTag('dns.address', result)
+    }
+
+    return ctx.parentStore
+  }
+}
+
+module.exports = DNSLookupPlugin

package/packages/datadog-plugin-dns/src/lookup_service.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+
+class DNSLookupServicePlugin extends ClientPlugin {
+  static id = 'dns'
+  static operation = 'lookup_service'
+
+  bindStart (ctx) {
+    const [address, port] = ctx.args
+
+    this.startSpan('dns.lookup_service', {
+      service: this.config.service,
+      resource: `${address}:${port}`,
+      kind: 'client',
+      meta: {
+        'dns.address': address,
+      },
+      metrics: {
+        'dns.port': port,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+}
+
+module.exports = DNSLookupServicePlugin

package/packages/datadog-plugin-dns/src/resolve.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+
+class DNSResolvePlugin extends ClientPlugin {
+  static id = 'dns'
+  static operation = 'resolve'
+
+  bindStart (ctx) {
+    const [hostname, maybeType] = ctx.args
+    const rrtype = typeof maybeType === 'string' ? maybeType : 'A'
+
+    this.startSpan('dns.resolve', {
+      service: this.config.service,
+      resource: `${rrtype} ${hostname}`,
+      kind: 'client',
+      meta: {
+        'dns.hostname': hostname,
+        'dns.rrtype': rrtype,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+}
+
+module.exports = DNSResolvePlugin

package/packages/datadog-plugin-dns/src/reverse.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+
+class DNSReversePlugin extends ClientPlugin {
+  static id = 'dns'
+  static operation = 'reverse'
+
+  bindStart (ctx) {
+    const [ip] = ctx.args
+
+    this.startSpan('dns.reverse', {
+      service: this.config.service,
+      resource: ip,
+      kind: 'client',
+      meta: {
+        'dns.ip': ip,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+}
+
+module.exports = DNSReversePlugin

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

@@ -0,0 +1,49 @@
+'use strict'
+
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+
+class ElasticsearchPlugin extends DatabasePlugin {
+  static id = 'elasticsearch'
+
+  bindStart (ctx) {
+    const { params } = ctx
+
+    const body = getBody(params.body || params.bulkBody)
+
+    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),
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  bindFinish (ctx) {
+    const { params } = ctx
+
+    const span = this.activeSpan
+    this.config.hooks.query(span, params)
+    super.finish(ctx)
+
+    return ctx.parentStore
+  }
+}
+
+function getBody (body) {
+  return body && JSON.stringify(body)
+}
+
+function quantizePath (path) {
+  return path && path.replaceAll(/[0-9]+/g, '?')
+}
+
+module.exports = ElasticsearchPlugin

package/packages/datadog-plugin-express/src/code_origin.js

@@ -0,0 +1,47 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+
+const { entryTags } = require('../../datadog-code-origin')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+class ExpressCodeOriginForSpansPlugin extends Plugin {
+  static id = 'express'
+
+  constructor (...args) {
+    super(...args)
+
+    const layerTags = new WeakMap()
+
+    // Middleware/request handling: apply pre-computed tags to spans
+    const handleMiddlewareEnter = ({ req, layer }) => {
+      const tags = layerTags.get(layer)
+      if (!tags) return
+      web.getContext(req)?.span?.addTags(tags)
+    }
+
+    this.addSub('apm:express:middleware:enter', handleMiddlewareEnter)
+    this.addSub('apm:router:middleware:enter', handleMiddlewareEnter)
+
+    // Route added handling: compute and cache tags
+    const handleRouteAdded = ({ topOfStackFunc, layer }) => {
+      if (!layer) return
+      if (layerTags.has(layer)) return
+      layerTags.set(layer, entryTags(topOfStackFunc))
+    }
+
+    if (this._tracerConfig.remoteConfig?.enabled) {
+      // When RC is enabled, use manual subscriptions (always pre-compute)
+      // This allows tags to be computed even when CO is disabled, so runtime enabling works
+      dc.channel('apm:express:route:added').subscribe(handleRouteAdded)
+      dc.channel('apm:router:route:added').subscribe(handleRouteAdded)
+    } else {
+      // When RC is disabled, use addSub (only computes when CO is enabled)
+      this.addSub('apm:express:route:added', handleRouteAdded)
+      this.addSub('apm:router:route:added', handleRouteAdded)
+    }
+  }
+}
+
+module.exports = ExpressCodeOriginForSpansPlugin

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

@@ -0,0 +1,17 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const ExpressTracingPlugin = require('./tracing')
+const ExpressCodeOriginForSpansPlugin = require('./code_origin')
+
+class ExpressPlugin extends CompositePlugin {
+  static id = 'express'
+  static get plugins () {
+    return {
+      tracing: ExpressTracingPlugin,
+      codeOriginForSpans: ExpressCodeOriginForSpansPlugin,
+    }
+  }
+}
+
+module.exports = ExpressPlugin

package/packages/datadog-plugin-express/src/tracing.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const RouterPlugin = require('../../datadog-plugin-router/src')
+
+class ExpressTracingPlugin extends RouterPlugin {
+  static id = 'express'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:express:request:handle', ({ req }) => {
+      this.setFramework(req, 'express', this.config)
+    })
+  }
+}
+
+module.exports = ExpressTracingPlugin

package/packages/datadog-plugin-fastify/src/code_origin.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+
+const { entryTags } = require('../../datadog-code-origin')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+const kCodeOriginForSpansTagsSym = Symbol('datadog.codeOriginForSpansTags')
+
+class FastifyCodeOriginForSpansPlugin extends Plugin {
+  static id = 'fastify'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:fastify:request:handle', ({ req, routeConfig }) => {
+      const tags = routeConfig?.[kCodeOriginForSpansTagsSym]
+      if (!tags) return
+      web.getContext(req)?.span?.addTags(tags)
+    })
+
+    if (this._tracerConfig.remoteConfig?.enabled) {
+      // When RC is enabled, use manual subscription (always pre-computes)
+      // This allows tags to be computed even when CO is disabled, so runtime enabling works
+      dc.channel('apm:fastify:route:added').subscribe(handleRouteAdded)
+    } else {
+      // When RC is disabled, use addSub (only computes when CO is enabled)
+      this.addSub('apm:fastify:route:added', handleRouteAdded)
+    }
+  }
+}
+
+module.exports = FastifyCodeOriginForSpansPlugin
+
+// Route added handling: compute and cache tags
+function handleRouteAdded ({ routeOptions, onRoute }) {
+  if (!routeOptions.config) routeOptions.config = {}
+  if (routeOptions.config[kCodeOriginForSpansTagsSym]) return
+  routeOptions.config[kCodeOriginForSpansTagsSym] = entryTags(onRoute)
+}

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

@@ -0,0 +1,17 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const FastifyTracingPlugin = require('./tracing')
+const FastifyCodeOriginForSpansPlugin = require('./code_origin')
+
+class FastifyPlugin extends CompositePlugin {
+  static id = 'fastify'
+  static get plugins () {
+    return {
+      tracing: FastifyTracingPlugin,
+      codeOriginForSpans: FastifyCodeOriginForSpansPlugin,
+    }
+  }
+}
+
+module.exports = FastifyPlugin

package/packages/datadog-plugin-fastify/src/tracing.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const RouterPlugin = require('../../datadog-plugin-router/src')
+const { storage } = require('../../datadog-core')
+
+class FastifyTracingPlugin extends RouterPlugin {
+  static id = 'fastify'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:fastify:request:handle', ({ req }) => {
+      this.setFramework(req, 'fastify', this.config)
+    })
+
+    this.addBind('datadog:fastify:pre-parsing:start', getParentStore)
+    this.addBind('datadog:fastify:pre-validation:start', getParentStore)
+
+    this.addSub('datadog:fastify:pre-parsing:finish', (ctx) => {
+      return ctx.parentStore
+    })
+    this.addSub('datadog:fastify:pre-validation:finish', (ctx) => {
+      return ctx.parentStore
+    })
+    this.addSub('datadog:fastify:callback:execute', getParentStore)
+  }
+}
+
+function getParentStore (ctx) {
+  ctx.parentStore = ctx.parentStore ?? storage('legacy').getStore()
+  return ctx.parentStore
+}
+
+module.exports = FastifyTracingPlugin

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

@@ -0,0 +1,40 @@
+'use strict'
+
+const HttpClientPlugin = require('../../datadog-plugin-http/src/client')
+
+class FetchPlugin extends HttpClientPlugin {
+  static id = 'fetch'
+  static prefix = 'tracing:apm:fetch:request'
+
+  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)
+
+    for (const name in options.headers) {
+      if (!req.headers.has(name)) {
+        req.headers.set(name, options.headers[name])
+      }
+    }
+
+    return store
+  }
+
+  error (ctx) {
+    if (ctx.error.name === 'AbortError') return
+    return super.error(ctx)
+  }
+
+  asyncEnd (ctx) {
+    ctx.res = ctx.result
+    return this.finish(ctx)
+  }
+}
+
+module.exports = FetchPlugin

package/packages/datadog-plugin-find-my-way/src/index.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+class FindMyWayPlugin extends Plugin {
+  static id = 'find-my-way'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:find-my-way:request:route', ({ req, route }) => {
+      web.setRoute(req, route)
+    })
+  }
+}
+
+module.exports = FindMyWayPlugin

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

@@ -0,0 +1,52 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+class FsPlugin extends TracingPlugin {
+  static id = 'fs'
+  static operation = 'operation'
+
+  configure (...args) {
+    return super.configure(...args)
+  }
+
+  bindStart (ctx) {
+    if (!this.activeSpan) return this.skip()
+
+    const { operation, ...params } = ctx
+    const lowerOp = operation.toLowerCase()
+    const flag = params.flag || params.flags || (params.options && (params.options.flag || params.options.flags))
+    const defaultFlag = ((lowerOp.includes('open') || lowerOp.includes('read')) && 'r') ||
+      (lowerOp.includes('write') && 'w') ||
+      (lowerOp.includes('append') && 'a')
+    const fd = params.fd || (typeof params.file === 'number' && params.file)
+    const path = params.path || params.prefix || params.filename || (typeof params.file === 'string' && params.file)
+    const uid = typeof params.uid === 'number' && params.uid.toString()
+    const gid = typeof params.gid === 'number' && params.gid.toString()
+    const mode = typeof params.mode === 'number' ? params.mode.toString(8) : params.mode
+
+    this.startSpan('fs.operation', {
+      service: this.config.service,
+      resource: operation,
+      kind: 'internal',
+      meta: {
+        'file.descriptor': ((fd !== null && typeof fd === 'object') || typeof fd === 'number') ? fd.toString() : '',
+        'file.dest': params.dest || params.newPath || (params.target && params.path),
+        'file.flag': String(flag || defaultFlag || ''),
+        'file.gid': gid || '',
+        'file.mode': mode,
+        'file.path': path || '',
+        'file.src': params.src || params.oldPath || params.existingPath || params.target,
+        'file.uid': uid || '',
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  bindFinish (ctx) {
+    return ctx.parentStore
+  }
+}
+
+module.exports = FsPlugin

package/packages/datadog-plugin-google-cloud-pubsub/src/client.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+
+class GoogleCloudPubsubClientPlugin extends ClientPlugin {
+  static id = 'google-cloud-pubsub'
+  static type = 'messaging'
+  static operation = 'request'
+
+  start (ctx) {
+    const { request, api, projectId, storedContext } = ctx
+
+    if (api === 'publish') return
+
+    const spanOptions = {
+      service: this.config.service || this.serviceName(),
+      resource: [api, request.name].filter(Boolean).join(' '),
+      kind: this.constructor.kind,
+      meta: {
+        'pubsub.method': api,
+        'gcloud.project_id': projectId,
+      },
+    }
+
+    /**
+     * Use stored context from consumer plugin to link acknowledge span to message processing span.
+     * Without this, the acknowledge span would be orphaned (no async context available).
+     */
+    if (storedContext?.span) {
+      spanOptions.childOf = storedContext.span.context()
+    }
+
+    this.startSpan(this.operationName(), spanOptions, ctx)
+
+    return ctx.currentStore
+  }
+}
+
+module.exports = GoogleCloudPubsubClientPlugin