@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,48 @@
+'use strict'
+
+const tracingChannel = require('dc-polyfill').tracingChannel
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  addHook,
+} = require('./helpers/instrument')
+
+const ch = tracingChannel('apm:aerospike:command')
+
+function wrapCreateCommand (createCommand) {
+  if (typeof createCommand !== 'function') return createCommand
+
+  return function commandWithTrace () {
+    const CommandClass = createCommand.apply(this, arguments)
+
+    if (!CommandClass) return CommandClass
+
+    shimmer.wrap(CommandClass.prototype, 'process', wrapProcess)
+
+    return CommandClass
+  }
+}
+
+function wrapProcess (process) {
+  return function (...args) {
+    const cb = args[0]
+    if (typeof cb !== 'function') return process.apply(this, args)
+
+    const ctx = {
+      commandName: this.constructor.name,
+      commandArgs: this.args,
+      clientConfig: this.client.config,
+    }
+
+    return ch.traceCallback(process, -1, ctx, this, ...args)
+  }
+}
+
+addHook({
+  name: 'aerospike',
+  file: 'lib/commands/command.js',
+  versions: ['4', '5', '6'],
+},
+commandFactory => {
+  return shimmer.wrapFunction(commandFactory, f => wrapCreateCommand(f))
+})

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

@@ -0,0 +1,119 @@
+'use strict'
+
+const { channel, tracingChannel } = require('dc-polyfill')
+const shimmer = require('../../datadog-shimmer')
+const { addHook, getHooks } = require('./helpers/instrument')
+
+const vercelAiTracingChannel = tracingChannel('dd-trace:vercel-ai')
+const vercelAiSpanSetAttributesChannel = channel('dd-trace:vercel-ai:span:setAttributes')
+
+const tracers = new WeakSet()
+
+function wrapTracer (tracer) {
+  if (tracers.has(tracer)) {
+    return
+  }
+
+  tracers.add(tracer)
+
+  shimmer.wrap(tracer, 'startActiveSpan', function (startActiveSpan) {
+    return function () {
+      const name = arguments[0]
+      const options = arguments.length > 2 ? (arguments[1] ?? {}) : {} // startActiveSpan(name, fn)
+      const cb = arguments[arguments.length - 1]
+
+      const ctx = {
+        name,
+        attributes: options.attributes ?? {},
+      }
+
+      arguments[arguments.length - 1] = shimmer.wrapFunction(cb, function (originalCb) {
+        return function (span) {
+          // the below is necessary in the case that the span is vercel ai's noopSpan.
+          // while we don't want to patch the noopSpan more than once, we do want to treat each as a
+          // fresh instance. However, this is really not necessary for non-noop spans, but not sure
+          // how to differentiate.
+          const freshSpan = Object.create(span) // TODO: does this cause memory leaks?
+
+          shimmer.wrap(freshSpan, 'end', function (spanEnd) {
+            return function () {
+              vercelAiTracingChannel.asyncEnd.publish(ctx)
+              return spanEnd.apply(this, arguments)
+            }
+          })
+
+          shimmer.wrap(freshSpan, 'setAttributes', function (setAttributes) {
+            return function (attributes) {
+              vercelAiSpanSetAttributesChannel.publish({ ctx, attributes })
+              return setAttributes.apply(this, arguments)
+            }
+          })
+
+          shimmer.wrap(freshSpan, 'recordException', function (recordException) {
+            return function (exception) {
+              ctx.error = exception
+              vercelAiTracingChannel.error.publish(ctx)
+              return recordException.apply(this, arguments)
+            }
+          })
+
+          return originalCb.call(this, freshSpan)
+        }
+      })
+
+      return vercelAiTracingChannel.start.runStores(ctx, () => {
+        const result = startActiveSpan.apply(this, arguments)
+        vercelAiTracingChannel.end.publish(ctx)
+        return result
+      })
+    }
+  })
+}
+
+for (const hook of getHooks('ai')) {
+  if (hook.file === 'dist/index.js') {
+    // if not removed, the below hook will never match correctly
+    // however, it is still needed in the orchestrion definition
+    hook.file = null
+  }
+
+  addHook(hook, exports => {
+    const getTracerChannel = tracingChannel('orchestrion:ai:getTracer')
+    getTracerChannel.subscribe({
+      end (ctx) {
+        const { arguments: args, result: tracer } = ctx
+        const { isEnabled } = args[0] ?? {}
+
+        if (isEnabled !== false) {
+          wrapTracer(tracer)
+        }
+      },
+    })
+
+    /**
+     * We patch this function to ensure that the telemetry attributes/tags are set always,
+     * even when telemetry options are not specified. This is to ensure easy use of this integration.
+     *
+     * If it is explicitly disabled, however, we will not change the options.
+     */
+    const selectTelemetryAttributesChannel = tracingChannel('orchestrion:ai:selectTelemetryAttributes')
+    selectTelemetryAttributesChannel.subscribe({
+      start (ctx) {
+        const { arguments: args } = ctx
+        const options = args[0]
+
+        if (options.telemetry?.isEnabled !== false) {
+          args[0] = {
+            ...options,
+            telemetry: {
+              ...options.telemetry,
+              isEnabled: true,
+            },
+          }
+        }
+      },
+    })
+
+    return exports
+  })
+}

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

@@ -0,0 +1,73 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+
+addHook({ name: 'amqp10', file: 'lib/sender_link.js', versions: ['>=3'] }, SenderLink => {
+  const startCh = channel('apm:amqp10:send:start')
+  const finishCh = channel('apm:amqp10:send:finish')
+  const errorCh = channel('apm:amqp10:send:error')
+  shimmer.wrap(SenderLink.prototype, 'send', send => function (msg, options) {
+    if (!startCh.hasSubscribers) {
+      return send.apply(this, arguments)
+    }
+    const ctx = { link: this }
+
+    return startCh.runStores(ctx, () => {
+      try {
+        const promise = send.apply(this, arguments)
+
+        if (!promise) {
+          finish(finishCh, errorCh)
+          return promise
+        }
+
+        promise.then(
+          () => finish(finishCh, errorCh, null, ctx),
+          e => finish(finishCh, errorCh, e, ctx)
+        )
+        return promise
+      } catch (err) {
+        finish(finishCh, errorCh, err, ctx)
+        throw err
+      }
+    })
+  })
+  return SenderLink
+})
+
+addHook({ name: 'amqp10', file: 'lib/receiver_link.js', versions: ['>=3'] }, ReceiverLink => {
+  const startCh = channel('apm:amqp10:receive:start')
+  const finishCh = channel('apm:amqp10:receive:finish')
+  const errorCh = channel('apm:amqp10:receive:error')
+  shimmer.wrap(ReceiverLink.prototype, '_messageReceived', messageReceived => function (transferFrame) {
+    if (!transferFrame || transferFrame.aborted || transferFrame.more) {
+      return messageReceived.apply(this, arguments)
+    }
+    const ctx = { link: this }
+
+    return startCh.runStores(ctx, () => {
+      try {
+        return messageReceived.apply(this, arguments)
+      } catch (err) {
+        ctx.error = err
+        errorCh.publish(ctx)
+        throw err
+      } finally {
+        finishCh.publish(ctx)
+      }
+    })
+  })
+  return ReceiverLink
+})
+
+function finish (finishCh, errorCh, error, ctx) {
+  if (error) {
+    ctx.error = error
+    errorCh.publish(ctx)
+  }
+  finishCh.publish(ctx)
+}

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

@@ -0,0 +1,146 @@
+'use strict'
+
+const kebabCase = require('../../datadog-core/src/utils/src/kebabcase')
+const shimmer = require('../../datadog-shimmer')
+
+const { NODE_MAJOR, NODE_MINOR } = require('../../../version')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+const MIN_VERSION = ((NODE_MAJOR > 22) || (NODE_MAJOR === 22 && NODE_MINOR >= 2)) ? '>=0.5.3' : '>=0.5.0'
+
+const commandStartCh = channel('apm:amqplib:command:start')
+const commandFinishCh = channel('apm:amqplib:command:finish')
+const commandErrorCh = channel('apm:amqplib:command:error')
+
+const consumeStartCh = channel('apm:amqplib:consume:start')
+const consumeFinishCh = channel('apm:amqplib:consume:finish')
+
+const publishStartCh = channel('apm:amqplib:publish:start')
+const publishFinishCh = channel('apm:amqplib:publish:finish')
+const publishErrorCh = channel('apm:amqplib:publish:error')
+
+const methods = {}
+
+addHook({ name: 'amqplib', file: 'lib/defs.js', versions: [MIN_VERSION] }, defs => {
+  for (const [key, value] of Object.entries(defs)) {
+    if (Number.isInteger(value) && isCamelCase(key)) {
+      methods[value] = kebabCase(key).replaceAll('-', '.')
+    }
+  }
+  return defs
+})
+
+addHook({ name: 'amqplib', file: 'lib/channel_model.js', versions: [MIN_VERSION] }, x => {
+  shimmer.wrap(x.Channel.prototype, 'get', getMessage => function (queue, options) {
+    return getMessage.apply(this, arguments).then(message => {
+      if (message === null) {
+        return message
+      }
+      const ctx = { method: 'basic.get', message, fields: message.fields, queue }
+      consumeStartCh.runStores(ctx, () => {
+        // finish right away
+        consumeFinishCh.publish(ctx)
+      })
+      return message
+    })
+  })
+  shimmer.wrap(x.Channel.prototype, 'consume', consume => function (queue, callback, options) {
+    if (!consumeStartCh.hasSubscribers) {
+      return consume.apply(this, arguments)
+    }
+    arguments[1] = (message, ...args) => {
+      if (message === null) {
+        return callback(message, ...args)
+      }
+      const ctx = { method: 'basic.deliver', message, fields: message.fields, queue }
+      return consumeStartCh.runStores(ctx, () => {
+        // finish right away
+        const result = callback(message, ...args)
+        consumeFinishCh.publish(ctx)
+        return result
+      })
+    }
+    return consume.apply(this, arguments)
+  })
+  return x
+})
+
+addHook({ name: 'amqplib', file: 'lib/callback_model.js', versions: [MIN_VERSION] }, channel => {
+  shimmer.wrap(channel.Channel.prototype, 'get', getMessage => function (queue, options, callback) {
+    if (!commandStartCh.hasSubscribers) {
+      return getMessage.apply(this, arguments)
+    }
+    arguments[2] = (error, message, ...args) => {
+      if (error !== null || message === null) {
+        return callback(error, message, ...args)
+      }
+      const ctx = { method: 'basic.get', message, fields: message.fields, queue }
+      return consumeStartCh.runStores(ctx, () => {
+        const result = callback(error, message, ...args)
+        consumeFinishCh.publish(ctx)
+        return result
+      })
+    }
+    return getMessage.apply(this, arguments)
+  })
+  shimmer.wrap(channel.Channel.prototype, 'consume', consume => function (queue, callback) {
+    if (!consumeStartCh.hasSubscribers) {
+      return consume.apply(this, arguments)
+    }
+    arguments[1] = (message, ...args) => {
+      if (message === null) {
+        return callback(message, ...args)
+      }
+      const ctx = { method: 'basic.deliver', message, fields: message.fields, queue }
+      return consumeStartCh.runStores(ctx, () => {
+        const result = callback(message, ...args)
+        consumeFinishCh.publish(ctx)
+        return result
+      })
+    }
+    return consume.apply(this, arguments)
+  })
+  return channel
+})
+
+addHook({ name: 'amqplib', file: 'lib/channel.js', versions: [MIN_VERSION] }, channel => {
+  shimmer.wrap(channel.Channel.prototype, 'sendImmediately', sendImmediately => function (method, fields) {
+    return instrument(
+      sendImmediately, this, arguments, methods[method], fields, null, commandStartCh, commandFinishCh, commandErrorCh
+    )
+  })
+
+  shimmer.wrap(channel.Channel.prototype, 'sendMessage', sendMessage => function (fields) {
+    return instrument(
+      sendMessage, this, arguments, 'basic.publish', fields, arguments[2],
+      publishStartCh, publishFinishCh, publishErrorCh
+    )
+  })
+  return channel
+})
+
+function instrument (send, channel, args, method, fields, message, startCh, finishCh, errorCh) {
+  if (!startCh.hasSubscribers || method === 'basic.get') {
+    return send.apply(channel, args)
+  }
+
+  const ctx = { channel, method, fields, message }
+  return startCh.runStores(ctx, () => {
+    try {
+      return send.apply(channel, args)
+    } catch (err) {
+      ctx.error = err
+      errorCh.publish(ctx)
+
+      throw err
+    } finally {
+      finishCh.publish(ctx)
+    }
+  })
+}
+
+function isCamelCase (str) {
+  return /([A-Z][a-z0-9]+)+/.test(str)
+}

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

@@ -0,0 +1,127 @@
+'use strict'
+
+const { channel, tracingChannel } = require('dc-polyfill')
+const shimmer = require('../../datadog-shimmer')
+const { addHook } = require('./helpers/instrument')
+
+const anthropicTracingChannel = tracingChannel('apm:anthropic:request')
+const onStreamedChunkCh = channel('apm:anthropic:request:chunk')
+
+function wrapStreamIterator (iterator, ctx) {
+  return function () {
+    const itr = iterator.apply(this, arguments)
+    shimmer.wrap(itr, 'next', next => function () {
+      return next.apply(this, arguments)
+        .then(res => {
+          const { done, value: chunk } = res
+          onStreamedChunkCh.publish({ ctx, chunk, done })
+
+          if (done) {
+            finish(ctx)
+          }
+
+          return res
+        })
+        .catch(error => {
+          finish(ctx, null, error)
+          throw error
+        })
+    })
+
+    return itr
+  }
+}
+
+function wrapCreate (create) {
+  return function () {
+    if (!anthropicTracingChannel.start.hasSubscribers) {
+      return create.apply(this, arguments)
+    }
+
+    const options = arguments[0]
+    const stream = options.stream
+
+    const ctx = { options, resource: 'create' }
+
+    return anthropicTracingChannel.start.runStores(ctx, () => {
+      let apiPromise
+      try {
+        apiPromise = create.apply(this, arguments)
+      } catch (error) {
+        finish(ctx, null, error)
+        throw error
+      }
+
+      shimmer.wrap(apiPromise, 'parse', parse => function () {
+        return parse.apply(this, arguments)
+          .then(response => {
+            if (stream) {
+              shimmer.wrap(response, Symbol.asyncIterator, iterator => wrapStreamIterator(iterator, ctx))
+            } else {
+              finish(ctx, response, null)
+            }
+
+            return response
+          }).catch(error => {
+            finish(ctx, null, error)
+            throw error
+          })
+      })
+
+      anthropicTracingChannel.end.publish(ctx)
+
+      return apiPromise
+    })
+  }
+}
+
+function finish (ctx, result, error) {
+  if (error) {
+    ctx.error = error
+    anthropicTracingChannel.error.publish(ctx)
+  }
+
+  // streamed responses are handled and set separately
+  ctx.result ??= result
+
+  anthropicTracingChannel.asyncEnd.publish(ctx)
+}
+
+const extensions = ['js', 'mjs']
+for (const extension of extensions) {
+  addHook({
+    name: '@anthropic-ai/sdk',
+    file: `resources/messages.${extension}`,
+    versions: ['>=0.14.0 <0.33.0'],
+  }, exports => {
+    const Messages = exports.Messages
+
+    shimmer.wrap(Messages.prototype, 'create', wrapCreate)
+
+    return exports
+  })
+
+  addHook({
+    name: '@anthropic-ai/sdk',
+    file: `resources/messages/messages.${extension}`,
+    versions: ['>=0.33.0'],
+  }, exports => {
+    const Messages = exports.Messages
+
+    shimmer.wrap(Messages.prototype, 'create', wrapCreate)
+
+    return exports
+  })
+
+  addHook({
+    name: '@anthropic-ai/sdk',
+    file: `resources/beta/messages/messages.${extension}`,
+    versions: ['>=0.33.0'],
+  }, exports => {
+    const Messages = exports.Messages
+
+    shimmer.wrap(Messages.prototype, 'create', wrapCreate)
+
+    return exports
+  })
+}

package/packages/datadog-instrumentations/src/apollo-server-core.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+const shimmer = require('../../datadog-shimmer')
+const { addHook } = require('./helpers/instrument')
+
+const requestChannel = dc.tracingChannel('datadog:apollo-server-core:request')
+
+addHook({ name: 'apollo-server-core', file: 'dist/runHttpQuery.js', versions: ['>3.0.0'] }, runHttpQueryModule => {
+  const HttpQueryError = runHttpQueryModule.HttpQueryError
+
+  shimmer.wrap(runHttpQueryModule, 'runHttpQuery', function wrapRunHttpQuery (originalRunHttpQuery) {
+    return function runHttpQuery () {
+      if (!requestChannel.start.hasSubscribers) {
+        return originalRunHttpQuery.apply(this, arguments)
+      }
+
+      const abortController = new AbortController()
+      const abortData = {}
+
+      const runHttpQueryResult = requestChannel.tracePromise(
+        originalRunHttpQuery,
+        { abortController, abortData },
+        this,
+        ...arguments)
+
+      const abortPromise = new Promise((resolve, reject) => {
+        abortController.signal.addEventListener('abort', (event) => {
+          // runHttpQuery callbacks are writing the response on resolve/reject.
+          // We should return blocking data in the apollo-server-core HttpQueryError object
+          reject(new HttpQueryError(abortData.statusCode, abortData.message, true, abortData.headers))
+        }, { once: true })
+      })
+
+      return Promise.race([runHttpQueryResult, abortPromise])
+    }
+  })
+
+  return runHttpQueryModule
+})

package/packages/datadog-instrumentations/src/apollo-server.js

@@ -0,0 +1,135 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook } = require('./helpers/instrument')
+
+const graphqlMiddlewareChannel = dc.tracingChannel('datadog:apollo:middleware')
+const apolloHttpServerChannel = dc.tracingChannel('datadog:apollo:httpserver')
+
+const requestChannel = dc.tracingChannel('datadog:apollo:request')
+
+let HeaderMap
+
+function wrapExecuteHTTPGraphQLRequest (originalExecuteHTTPGraphQLRequest) {
+  return function executeHTTPGraphQLRequest () {
+    if (!HeaderMap || !requestChannel.start.hasSubscribers) {
+      return originalExecuteHTTPGraphQLRequest.apply(this, arguments)
+    }
+
+    const abortController = new AbortController()
+    const abortData = {}
+
+    const graphqlResponseData = requestChannel.tracePromise(
+      originalExecuteHTTPGraphQLRequest,
+      { abortController, abortData },
+      this,
+      ...arguments)
+
+    const abortPromise = new Promise((resolve, reject) => {
+      abortController.signal.addEventListener('abort', (event) => {
+        // This method is expected to return response data
+        // with headers, status and body
+        const headers = new HeaderMap()
+        for (const key of Object.keys(abortData.headers)) {
+          headers.set(key, abortData.headers[key])
+        }
+
+        resolve({
+          headers,
+          status: abortData.statusCode,
+          body: {
+            kind: 'complete',
+            string: abortData.message,
+          },
+        })
+      }, { once: true })
+    })
+
+    return Promise.race([abortPromise, graphqlResponseData])
+  }
+}
+
+function apolloExpress4Hook (express4) {
+  shimmer.wrap(express4, 'expressMiddleware', function wrapExpressMiddleware (originalExpressMiddleware) {
+    return function expressMiddleware (server, options) {
+      const originalMiddleware = originalExpressMiddleware.apply(this, arguments)
+
+      return shimmer.wrapFunction(originalMiddleware, originalMiddleware => function (req, res, next) {
+        if (!graphqlMiddlewareChannel.start.hasSubscribers) {
+          return originalMiddleware.apply(this, arguments)
+        }
+
+        return graphqlMiddlewareChannel.traceSync(originalMiddleware, { req }, this, ...arguments)
+      })
+    }
+  })
+  return express4
+}
+
+function apolloHeaderMapHook (headerMap) {
+  HeaderMap = headerMap.HeaderMap
+  return headerMap
+}
+
+function apolloServerHook (apolloServer) {
+  shimmer.wrap(apolloServer.ApolloServer.prototype, 'executeHTTPGraphQLRequest', wrapExecuteHTTPGraphQLRequest)
+  return apolloServer
+}
+
+function wrapEmit (emit) {
+  return function wrappedEmit (event, req, res) {
+    if (event === 'request' && req && res && apolloHttpServerChannel.start.hasSubscribers) {
+      return apolloHttpServerChannel.traceSync(emit, { req }, this, ...arguments)
+    }
+
+    return emit.apply(this, arguments)
+  }
+}
+
+function wrapListen (originalListen) {
+  return function wrappedListen () {
+    shimmer.wrap(this, 'emit', wrapEmit)
+
+    return originalListen.apply(this, arguments)
+  }
+}
+
+function wrapHttpServer (original) {
+  return function wrappedHttpServer (options) {
+    if (options.httpServer && typeof options.httpServer.listen === 'function') {
+      shimmer.wrap(options.httpServer, 'listen', wrapListen)
+    }
+
+    return original.apply(this, arguments)
+  }
+}
+
+function apolloDrainHttpServerHook (drainModule) {
+  shimmer.wrap(drainModule, 'ApolloServerPluginDrainHttpServer', wrapHttpServer)
+
+  return drainModule
+}
+
+addHook({ name: '@apollo/server', file: 'dist/cjs/ApolloServer.js', versions: ['4'] }, apolloServerHook)
+
+addHook({ name: '@apollo/server', file: 'dist/cjs/express4/index.js', versions: ['4'] }, apolloExpress4Hook)
+
+addHook({ name: '@apollo/server', file: 'dist/cjs/utils/HeaderMap.js', versions: ['4'] }, apolloHeaderMapHook)
+
+addHook(
+  { name: '@apollo/server', file: 'dist/cjs/plugin/drainHttpServer/index.js', versions: ['>=5.0.0'] },
+  apolloDrainHttpServerHook
+)
+
+addHook(
+  { name: '@apollo/server', file: 'dist/cjs/runHttpQuery.js', versions: ['>=5.0.0'] },
+  (runHttpQueryModule) => {
+    shimmer.wrap(runHttpQueryModule, 'runHttpQuery', function wrapRunHttpQuery (originalRunHttpQuery) {
+      return wrapExecuteHTTPGraphQLRequest(originalRunHttpQuery)
+    })
+
+    return runHttpQueryModule
+  }
+)