@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-instrumentations/src/vm.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook } = require('./helpers/instrument')
+const names = ['vm', 'node:vm']
+
+const runScriptStartChannel = channel('datadog:vm:run-script:start')
+const sourceTextModuleStartChannel = channel('datadog:vm:source-text-module:start')
+
+addHook({ name: names }, function (vm) {
+  vm.Script = class extends vm.Script {
+    constructor (code) {
+      super(...arguments)
+
+      if (runScriptStartChannel.hasSubscribers && code) {
+        runScriptStartChannel.publish({ code })
+      }
+    }
+  }
+
+  if (vm.SourceTextModule && typeof vm.SourceTextModule === 'function') {
+    vm.SourceTextModule = class extends vm.SourceTextModule {
+      constructor (code) {
+        super(...arguments)
+
+        if (sourceTextModuleStartChannel.hasSubscribers && code) {
+          sourceTextModuleStartChannel.publish({ code })
+        }
+      }
+    }
+  }
+
+  shimmer.wrap(vm, 'runInContext', wrapVMMethod)
+  shimmer.wrap(vm, 'runInNewContext', wrapVMMethod)
+  shimmer.wrap(vm, 'runInThisContext', wrapVMMethod)
+  shimmer.wrap(vm, 'compileFunction', wrapVMMethod)
+
+  return vm
+})
+
+function wrapVMMethod (original) {
+  return function wrappedVMMethod (code) {
+    if (runScriptStartChannel.hasSubscribers && code) {
+      runScriptStartChannel.publish({ code })
+    }
+
+    return original.apply(this, arguments)
+  }
+}

package/packages/datadog-instrumentations/src/when.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook } = require('./helpers/instrument')
+const { wrapThen } = require('./helpers/promise')
+
+addHook({
+  name: 'when',
+  file: 'lib/Promise.js',
+  versions: ['>=3'],
+}, Promise => {
+  shimmer.wrap(Promise.prototype, 'then', wrapThen)
+  return Promise
+})

package/packages/datadog-instrumentations/src/winston.js

@@ -0,0 +1,78 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+
+const patched = new WeakSet()
+
+// Test Visibility log submission channels
+const configureCh = channel('ci:log-submission:winston:configure')
+const addTransport = channel('ci:log-submission:winston:add-transport')
+
+addHook({ name: 'winston', file: 'lib/winston/transports/index.js', versions: ['>=3'] }, transportsPackage => {
+  if (configureCh.hasSubscribers) {
+    configureCh.publish(transportsPackage.Http)
+  }
+
+  return transportsPackage
+})
+
+addHook({ name: 'winston', file: 'lib/winston/logger.js', versions: ['>=3'] }, Logger => {
+  const logCh = channel('apm:winston:log')
+  shimmer.wrap(Logger.prototype, 'write', write => {
+    return function wrappedWrite (chunk, enc, cb) {
+      if (logCh.hasSubscribers) {
+        const payload = { message: chunk }
+        logCh.publish(payload)
+        arguments[0] = payload.message
+      }
+      return write.apply(this, arguments)
+    }
+  })
+
+  shimmer.wrap(Logger.prototype, 'configure', configure => function () {
+    const configureResponse = configure.apply(this, arguments)
+    // After the original `configure`, because it resets transports
+    if (addTransport.hasSubscribers) {
+      addTransport.publish(this)
+    }
+    return configureResponse
+  })
+
+  return Logger
+})
+
+addHook({ name: 'winston', file: 'lib/winston/logger.js', versions: ['1', '2'] }, logger => {
+  const logCh = channel('apm:winston:log')
+  if (logger.Logger.prototype.configure) {
+    shimmer.wrap(logger.Logger.prototype, 'configure', configure => wrapMethod(configure, logCh))
+  }
+  shimmer.wrap(logger.Logger.prototype, 'add', configure => wrapMethod(configure, logCh))
+  return logger
+})
+
+function wrapMethod (method, logCh) {
+  return function methodWithTrace () {
+    const result = method.apply(this, arguments)
+
+    if (logCh.hasSubscribers) {
+      for (const name in this.transports) {
+        const transport = this.transports[name]
+
+        if (patched.has(transport) || typeof transport.log !== 'function') continue
+
+        shimmer.wrap(transport, 'log', log => function wrappedLog (level, msg, meta, callback) {
+          const payload = { message: meta || {} }
+          logCh.publish(payload)
+          arguments[2] = payload.message
+          log.apply(this, arguments)
+        })
+        patched.add(transport)
+      }
+    }
+    return result
+  }
+}

package/packages/datadog-instrumentations/src/ws.js

@@ -0,0 +1,264 @@
+'use strict'
+
+const { tracingChannel } = /** @type {import('node:diagnostics_channel')} */ (require('dc-polyfill'))
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  addHook,
+  channel,
+} = require('./helpers/instrument')
+
+const serverCh = tracingChannel('ws:server:connect')
+const producerCh = tracingChannel('ws:send')
+const receiverCh = tracingChannel('ws:receive')
+const closeCh = tracingChannel('ws:close')
+const emitCh = channel('tracing:ws:server:connect:emit')
+const setSocketCh = channel('tracing:ws:server:connect:setSocket')
+// TODO: Add a error channel / handle error events properly.
+
+/**
+ * @typedef {object} WebSocketServerPrototype
+ * @property {(...args: unknown[]) => unknown} handleUpgrade
+ * @property {(...args: unknown[]) => unknown} emit
+ */
+
+/**
+ * @typedef {{ prototype: WebSocketServerPrototype }} WebSocketServerClass
+ */
+
+/**
+ * @typedef {object} WebSocketPrototype
+ * @property {(...args: unknown[]) => unknown} send
+ * @property {(...args: unknown[]) => unknown} close
+ * @property {(...args: unknown[]) => unknown} setSocket
+ */
+
+/**
+ * @typedef {{ prototype: WebSocketPrototype }} WebSocketClass
+ */
+
+/**
+ * @typedef {object} ReceiverPrototype
+ * @property {(eventName: string, listener: (...args: unknown[]) => unknown) => unknown} on
+ * @property {(eventName: string, listener: (...args: unknown[]) => unknown) => unknown} addListener
+ */
+
+/**
+ * @typedef {{ prototype: ReceiverPrototype }} ReceiverClass
+ */
+
+/**
+ * @typedef {string | Buffer | ArrayBuffer | ArrayBufferView | Blob | Buffer[]} WebSocketMessageData
+ */
+
+/**
+ * @typedef {object} WebSocketInstance
+ * @property {(...args: unknown[]) => unknown} emit
+ * @property {(eventName: string) => number} [listenerCount]
+ * @property {{ _socket?: unknown } | undefined} [_sender]
+ * @property {unknown} [_receiver]
+ */
+
+let kWebSocketSymbol
+
+function wrapHandleUpgrade (handleUpgrade) {
+  return function () {
+    const [req, socket, , cb] = arguments
+    if (!serverCh.start.hasSubscribers || typeof cb !== 'function') {
+      return handleUpgrade.apply(this, arguments)
+    }
+
+    const ctx = { req, socket }
+
+    arguments[3] = function () {
+      return serverCh.asyncStart.runStores(ctx, () => {
+        try {
+          return cb.apply(this, arguments)
+        } finally {
+          serverCh.asyncEnd.publish(ctx)
+        }
+      }, this, ...arguments)
+    }
+    return serverCh.traceSync(handleUpgrade, ctx, this, ...arguments)
+  }
+}
+
+function wrapSend (send) {
+  return function wrappedSend (...args) {
+    if (!producerCh.start.hasSubscribers) {
+      return send.apply(this, arguments)
+    }
+
+    const [data, options, cb] = arguments
+
+    const ctx = { data, socket: this._sender?._socket }
+
+    return typeof cb === 'function'
+      ? producerCh.traceCallback(send, undefined, ctx, this, data, options, cb)
+      : producerCh.traceSync(send, ctx, this, data, options, cb)
+  }
+}
+
+function createWrapEmit (emit) {
+  return function (title, headers, req) {
+    if (!serverCh.start.hasSubscribers || title !== 'headers') {
+      return emit.apply(this, arguments)
+    }
+
+    const ctx = { req }
+    ctx.req.resStatus = headers[0].split(' ')[1]
+
+    emitCh.runStores(ctx, () => {
+      try {
+        return emit.apply(this, arguments)
+      } finally {
+        emitCh.publish(ctx)
+      }
+    })
+  }
+}
+
+/**
+ * @param {Function} setSocket
+ * @returns {(...args: unknown[]) => unknown}
+ */
+/**
+ * @param {Function} on
+ * @returns {(...args: unknown[]) => unknown}
+ */
+function wrapReceiverOn (on) {
+  return function wrappedOn (eventName, handler) {
+    if (eventName !== 'message' || typeof handler !== 'function') {
+      return on.apply(this, arguments)
+    }
+
+    const wrappedHandler = function (data, isBinary) {
+      if (!receiverCh.start.hasSubscribers || !kWebSocketSymbol) {
+        return handler.call(this, data, isBinary)
+      }
+
+      const websocket = /** @type {WebSocketInstance | undefined} */ (this[kWebSocketSymbol])
+      // Avoid receive spans when no one listens to messages.
+      if (websocket && typeof websocket.listenerCount === 'function' && websocket.listenerCount('message') === 0) {
+        return handler.call(this, data, isBinary)
+      }
+      const socket = websocket?._sender?._socket
+      if (!socket) {
+        return handler.call(this, data, isBinary)
+      }
+
+      const byteLength = dataLength(/** @type {WebSocketMessageData} */ (data))
+      const ctx = { data, binary: isBinary, socket, byteLength }
+
+      return receiverCh.traceSync(handler, ctx, this, data, isBinary)
+    }
+
+    return on.call(this, eventName, wrappedHandler)
+  }
+}
+
+function wrapClose (close) {
+  return function (code, data) {
+    // _closeFrameReceived is set to true when receiver receives a close frame from a peer
+    // _closeFrameSent is set to true when a close frame is sent
+    // in the case that a close frame is received and not yet sent then connection is closed by peer
+    // if both are true then the self is sending the close event
+    const isPeerClose = this._closeFrameReceived === true && this._closeFrameSent === false
+
+    const ctx = { code, data, socket: this._sender?._socket, isPeerClose }
+
+    return closeCh.traceSync(close, ctx, this, ...arguments)
+  }
+}
+
+addHook({
+  name: 'ws',
+  file: 'lib/websocket-server.js',
+  versions: ['>=8.0.0'],
+}, moduleExports => {
+  const ws = /** @type {WebSocketServerClass} */ (moduleExports)
+  shimmer.wrap(ws.prototype, 'handleUpgrade', wrapHandleUpgrade)
+  shimmer.wrap(ws.prototype, 'emit', createWrapEmit)
+  return ws
+})
+
+/**
+ * Prevent internal event handlers (data, close, etc.) registered by the ws library to
+ * capture the connection span in their async context. Otherwise, the
+ * finished connection span is retained for the entire lifetime of the WebSocket
+ * (via ACF -> handle -> WeakMap).
+ *
+ * @param {Function} setSocket
+ * @returns {(...args: unknown[]) => unknown}
+ */
+function wrapSetSocket (setSocket) {
+  return function wrappedSetSocket (...args) {
+    if (!setSocketCh.hasSubscribers) {
+      return setSocket.apply(this, args)
+    }
+    return setSocketCh.runStores({}, () => {
+      return setSocket.apply(this, args)
+    })
+  }
+}
+
+addHook({
+  name: 'ws',
+  file: 'lib/websocket.js',
+  versions: ['>=8.0.0'],
+}, moduleExports => {
+  const ws = /** @type {WebSocketClass} */ (moduleExports)
+  shimmer.wrap(ws.prototype, 'setSocket', wrapSetSocket)
+  shimmer.wrap(ws.prototype, 'send', wrapSend)
+  shimmer.wrap(ws.prototype, 'close', wrapClose)
+
+  return ws
+})
+
+addHook({
+  name: 'ws',
+  file: 'lib/constants.js',
+  versions: ['>=8.0.0'],
+}, moduleExports => {
+  const constants = /** @type {{ kWebSocket?: symbol }} */ (moduleExports)
+  kWebSocketSymbol = constants.kWebSocket
+  return constants
+})
+
+addHook({
+  name: 'ws',
+  file: 'lib/receiver.js',
+  versions: ['>=8.0.0'],
+}, moduleExports => {
+  const Receiver = /** @type {ReceiverClass} */ (moduleExports)
+  shimmer.wrap(Receiver.prototype, 'on', wrapReceiverOn)
+  shimmer.wrap(Receiver.prototype, 'addListener', wrapReceiverOn)
+  return Receiver
+})
+
+/**
+ * @param {WebSocketMessageData} data
+ * @returns {number}
+ */
+function dataLength (data) {
+  if (typeof data === 'string') {
+    return Buffer.byteLength(data)
+  }
+  if (data instanceof Blob) {
+    return data.size
+  }
+  if (ArrayBuffer.isView(data)) {
+    return data.byteLength
+  }
+  if (data instanceof ArrayBuffer) {
+    return data.byteLength
+  }
+  let total = 0
+  if (Array.isArray(data)) {
+    const chunks = /** @type {Buffer[]} */ (data)
+    for (const chunk of chunks) {
+      total += chunk.length
+    }
+  }
+  return total
+}

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

@@ -0,0 +1,113 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+
+const AEROSPIKE_PEER_SERVICE = 'aerospike.namespace'
+
+class AerospikePlugin extends DatabasePlugin {
+  static id = 'aerospike'
+  static operation = 'command'
+  static system = 'aerospike'
+  static prefix = 'tracing:apm:aerospike:command'
+
+  static peerServicePrecursors = [AEROSPIKE_PEER_SERVICE]
+
+  bindStart (ctx) {
+    const { commandName, commandArgs } = ctx
+    const resourceName = commandName.slice(0, commandName.indexOf('Command'))
+    const store = storage('legacy').getStore()
+    const childOf = store ? store.span : null
+    const meta = getMeta(resourceName, commandArgs)
+
+    const span = this.startSpan(this.operationName(), {
+      childOf,
+      service: this.serviceName({ pluginConfig: this.config }),
+      type: 'aerospike',
+      kind: 'client',
+      resource: resourceName,
+      meta,
+    }, false)
+
+    ctx.parentStore = store
+    ctx.currentStore = { ...store, span }
+
+    return ctx.currentStore
+  }
+
+  bindAsyncStart (ctx) {
+    if (ctx.currentStore) {
+      // have to manually trigger peer service calculation when using tracing channel
+      this.tagPeerService(ctx.currentStore.span)
+      ctx.currentStore.span.finish()
+    }
+    return ctx.parentStore
+  }
+
+  end (ctx) {
+    if (ctx.result) {
+      // have to manually trigger peer service calculation when using tracing channel
+      this.tagPeerService(ctx.currentStore.span)
+      ctx.currentStore.span.finish()
+    }
+  }
+
+  error (ctx) {
+    if (ctx.error) {
+      const error = ctx.error
+      const span = ctx.currentStore.span
+      span.setTag('error', error)
+    }
+  }
+}
+
+function getMeta (resourceName, commandArgs) {
+  let meta = {}
+  if (resourceName.includes('Index')) {
+    const [ns, set, bin, exp, index] = commandArgs
+
+    // The `ext` argument was added to IndexCreate in 6.3.0
+    meta = commandArgs.length > 8
+      ? getMetaForIndex(ns, set, bin, index)
+      : getMetaForIndex(ns, set, bin, exp)
+  } else if (resourceName === 'Query') {
+    const { ns, set } = commandArgs[2]
+    meta = getMetaForQuery({ ns, set })
+  } else if (isKeyObject(commandArgs[0])) {
+    const { ns, set, key } = commandArgs[0]
+    meta = getMetaForKey(ns, set, key)
+  }
+  return meta
+}
+
+function getMetaForIndex (ns, set, bin, index) {
+  return {
+    [AEROSPIKE_PEER_SERVICE]: ns,
+    'aerospike.setname': set,
+    'aerospike.bin': bin,
+    'aerospike.index': index,
+  }
+}
+
+function getMetaForKey (ns, set, key) {
+  return {
+    'aerospike.key': `${ns}:${set}:${key}`,
+    [AEROSPIKE_PEER_SERVICE]: ns,
+    'aerospike.setname': set,
+    'aerospike.userkey': key,
+  }
+}
+
+function getMetaForQuery (queryObj) {
+  const { ns, set } = queryObj
+  return {
+    [AEROSPIKE_PEER_SERVICE]: ns,
+    'aerospike.setname': set,
+  }
+}
+
+function isKeyObject (obj) {
+  return obj && obj.ns !== undefined && obj.set !== undefined && obj.key !== undefined
+}
+
+module.exports = AerospikePlugin

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

@@ -0,0 +1,17 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const VercelAILLMObsPlugin = require('../../dd-trace/src/llmobs/plugins/ai')
+const VercelAITracingPlugin = require('./tracing')
+
+class VercelAIPlugin extends CompositePlugin {
+  static get id () { return 'ai' }
+  static get plugins () {
+    return {
+      llmobs: VercelAILLMObsPlugin,
+      tracing: VercelAITracingPlugin,
+    }
+  }
+}
+
+module.exports = VercelAIPlugin

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

@@ -0,0 +1,33 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const { getModelProvider } = require('./utils')
+
+class VercelAITracingPlugin extends TracingPlugin {
+  static id = 'ai'
+  static prefix = 'tracing:dd-trace:vercel-ai'
+
+  bindStart (ctx) {
+    const { attributes, name } = ctx
+
+    const model = attributes['ai.model.id']
+    const modelProvider = getModelProvider(attributes)
+
+    this.startSpan(name, {
+      meta: {
+        'resource.name': attributes['resource.name'] ?? name,
+        'ai.request.model': model,
+        'ai.request.model_provider': modelProvider,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    const span = ctx.currentStore?.span
+    span?.finish()
+  }
+}
+
+module.exports = VercelAITracingPlugin

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

@@ -0,0 +1,28 @@
+'use strict'
+
+const { parseModelId } = require('../../datadog-plugin-aws-sdk/src/services/bedrockruntime/utils')
+
+/**
+ * Get the model provider from the span tags or attributes.
+ * This is normalized to LLM Observability model provider standards.
+ *
+ * @param {Record<string, string>} tags
+ * @returns {string}
+ */
+function getModelProvider (tags) {
+  const modelProviderTag = tags['ai.model.provider']
+  const providerParts = modelProviderTag?.split('.')
+  const provider = providerParts?.[0]
+
+  if (provider === 'amazon-bedrock') {
+    const modelId = tags['ai.model.id']
+    const model = modelId && parseModelId(modelId)
+    return model?.modelProvider ?? provider
+  }
+
+  return provider
+}
+
+module.exports = {
+  getModelProvider,
+}

package/packages/datadog-plugin-amqp10/src/consumer.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
+const { getAddress, getShortName } = require('./util')
+
+class Amqp10ConsumerPlugin extends ConsumerPlugin {
+  static id = 'amqp10'
+  static system = 'amqp'
+
+  bindStart (ctx) {
+    const { link } = ctx
+
+    const source = getShortName(link)
+    const address = getAddress(link)
+
+    this.startSpan({
+      resource: ['receive', source].filter(Boolean).join(' '),
+      type: 'worker',
+      meta: {
+        'amqp.link.source.address': source,
+        'amqp.link.role': 'receiver',
+        'amqp.link.name': link.name,
+        'amqp.link.handle': link.handle,
+        'amqp.connection.host': address.host,
+        'amqp.connection.port': address.port,
+        'amqp.connection.user': address.user,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+}
+
+module.exports = Amqp10ConsumerPlugin

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

@@ -0,0 +1,17 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const ProducerPlugin = require('./producer')
+const ConsumerPlugin = require('./consumer')
+
+class Amqp10Plugin extends CompositePlugin {
+  static id = 'amqp10'
+  static get plugins () {
+    return {
+      producer: ProducerPlugin,
+      consumer: ConsumerPlugin,
+    }
+  }
+}
+
+module.exports = Amqp10Plugin

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

@@ -0,0 +1,37 @@
+'use strict'
+
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
+const { getAddress, getShortName } = require('./util')
+
+class Amqp10ProducerPlugin extends ProducerPlugin {
+  static id = 'amqp10'
+  static operation = 'send'
+  static system = 'amqp'
+
+  bindStart (ctx) {
+    const { link } = ctx
+
+    const address = getAddress(link)
+    const target = getShortName(link)
+
+    this.startSpan({
+      resource: ['send', target].filter(Boolean).join(' '),
+      meta: {
+        'amqp.link.target.address': target,
+        'amqp.link.role': 'sender',
+        'out.host': address.host,
+        [CLIENT_PORT_KEY]: address.port,
+        'amqp.link.name': link.name,
+        'amqp.link.handle': link.handle,
+        'amqp.connection.host': address.host,
+        'amqp.connection.port': address.port,
+        'amqp.connection.user': address.user,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+}
+
+module.exports = Amqp10ProducerPlugin