@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,272 @@
+'use strict'
+
+const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
+const { channel, addHook } = require('./helpers/instrument')
+const prismaHelperInit = channel('apm:prisma:helper:init')
+
+/**
+ * @typedef {object} EnvValue
+ * @property {string|undefined} [value]
+ * @property {string|null|undefined} [fromEnvVar]
+ */
+
+/**
+ * @typedef {object} DatasourceConfig
+ * @property {string|EnvValue|undefined} [url]
+ */
+
+/**
+ * @typedef {object} PrismaRuntimeConfig
+ * @property {Record<string, DatasourceConfig>|undefined} [inlineDatasources]
+ * @property {Record<string, { url?: string }>|undefined} [overrideDatasources]
+ * @property {Record<string, { url?: string }>|undefined} [datasources]
+ * @property {string[]|undefined} [datasourceNames]
+ */
+
+/**
+ * @typedef {object} DbConfig
+ * @property {string|undefined} [user]
+ * @property {string|undefined} [password]
+ * @property {string|undefined} [host]
+ * @property {string|number|undefined} [port]
+ * @property {string|undefined} [database]
+ */
+
+/**
+ * @typedef {object} AdapterConfig
+ * @property {string|undefined} [connectionString]
+ * @property {string|undefined} [user]
+ * @property {string|undefined} [password]
+ * @property {string|undefined} [host]
+ * @property {string|number|undefined} [port]
+ * @property {string|undefined} [database]
+ */
+
+/**
+ * @typedef {object} Adapter
+ * @property {AdapterConfig|undefined} [config]
+ * @property {{ options?: AdapterConfig }|undefined} [externalPool]
+ */
+
+/**
+ * @typedef {object} PrismaClientConfig
+ * @property {string|undefined} [datasourceUrl]
+ * @property {Record<string, { url?: string }>|undefined} [datasources]
+ * @property {Adapter|undefined} [adapter]
+ */
+
+/**
+ * @typedef {object} PrismaHelperCtx
+ * @property {DbConfig} [dbConfig]
+ * @property {import('../../datadog-plugin-prisma/src/datadog-tracing-helper')} [helper]
+ */
+
+/**
+ * @param {string|EnvValue|undefined} envValue
+ * @returns {string|undefined}
+ */
+function resolveEnvValue (envValue) {
+  return typeof envValue === 'object' && envValue
+    ? (envValue.value || getEnvironmentVariable(envValue.fromEnvVar ?? ''))
+    : envValue
+}
+
+/**
+ * @param {PrismaRuntimeConfig|undefined} config
+ * @param {string} datasourceName
+ * @returns {string|undefined}
+ */
+function resolveDatasourceUrl (config, datasourceName) {
+  return resolveEnvValue(config?.inlineDatasources?.[datasourceName]?.url) ??
+    config?.overrideDatasources?.[datasourceName]?.url ??
+    config?.datasources?.[datasourceName]?.url ??
+    getEnvironmentVariable('DATABASE_URL')
+}
+
+/**
+ * @param {DbConfig} dbConfig
+ * @returns {DbConfig|undefined}
+ */
+function normalizeDbConfig (dbConfig) {
+  dbConfig.port = dbConfig.port == null ? undefined : String(dbConfig.port)
+  const hasValues = dbConfig.user || dbConfig.password || dbConfig.host || dbConfig.port || dbConfig.database
+  return hasValues ? dbConfig : undefined
+}
+
+/**
+ * @param {Adapter|undefined} adapter
+ * @returns {DbConfig|undefined}
+ */
+function resolveAdapterDbConfig (adapter) {
+  const adapterConfig = adapter?.config || adapter?.externalPool?.options
+  if (!adapterConfig) {
+    return
+  }
+
+  if (typeof adapterConfig === 'string') {
+    return parseDBString(adapterConfig)
+  }
+
+  const parsed = parseDBString(adapterConfig.connectionString)
+  if (parsed) {
+    return parsed
+  }
+
+  return normalizeDbConfig({
+    user: adapterConfig.user,
+    password: adapterConfig.password,
+    host: adapterConfig.host,
+    port: adapterConfig.port,
+    database: adapterConfig.database,
+  })
+}
+
+/**
+ * @param {PrismaClientConfig|undefined} clientConfig
+ * @param {string} datasourceName
+ * @param {DbConfig|undefined} runtimeDbConfig
+ * @returns {DbConfig|undefined}
+ */
+function resolveClientDbConfig (clientConfig, datasourceName, runtimeDbConfig) {
+  return resolveAdapterDbConfig(clientConfig?.adapter) ||
+    parseDBString(clientConfig?.datasources?.[datasourceName]?.url ?? clientConfig?.datasourceUrl) ||
+    runtimeDbConfig
+}
+
+/**
+ * @param {unknown} runtime
+ * @param {string} versions
+ * @param {string} [name]
+ * @param {boolean} [isIitm]
+ * @returns {object}
+ */
+const prismaHook = (runtime, versions, name, isIitm) => {
+  /**
+   * @typedef {{ getPrismaClient?: (config: PrismaRuntimeConfig, ...args: unknown[]) => Function }} PrismaRuntime
+   */
+  const prismaRuntime = /** @type {PrismaRuntime} */ (runtime)
+  const originalGetPrismaClient = prismaRuntime.getPrismaClient
+
+  if (!originalGetPrismaClient) {
+    return runtime
+  }
+
+  /**
+   * @param {PrismaRuntimeConfig|undefined} config
+   */
+  const wrappedGetPrismaClient = function (config) {
+    const datasourceName = config?.datasourceNames?.[0] || 'db'
+    const runtimeDatasourceUrl = resolveDatasourceUrl(config, datasourceName)
+    const runtimeDbConfig = parseDBString(runtimeDatasourceUrl)
+
+    const PrismaClient = originalGetPrismaClient.call(this, config)
+    return class WrappedPrismaClientClass extends PrismaClient {
+      constructor (clientConfig) {
+        super(clientConfig)
+        /**
+         * @type {PrismaHelperCtx}
+         */
+        const prismaHelperCtx = {
+          dbConfig: resolveClientDbConfig(clientConfig, datasourceName, runtimeDbConfig),
+        }
+        prismaHelperInit.publish(prismaHelperCtx)
+
+        const helper = prismaHelperCtx.helper
+        if (helper) {
+          this._tracingHelper = helper
+          this._engine.tracingHelper = helper
+        }
+      }
+    }
+  }
+
+  if (isIitm) {
+    prismaRuntime.getPrismaClient = wrappedGetPrismaClient
+    return runtime
+  }
+
+  return new Proxy(prismaRuntime, {
+    get (target, prop) {
+      if (prop === 'getPrismaClient') {
+        return wrappedGetPrismaClient
+      }
+      return target[prop]
+    },
+  })
+}
+
+const prismaConfigs = [
+  { name: '@prisma/client', versions: ['>=6.1.0 <7.0.0'], filePattern: 'runtime/library.*' },
+  { name: './runtime/library.js', versions: ['>=6.1.0 <7.0.0'], file: 'runtime/library.js' },
+  { name: '@prisma/client', versions: ['>=7.0.0'], filePattern: 'runtime/client.*' },
+]
+
+for (const config of prismaConfigs) {
+  addHook(config, prismaHook)
+}
+
+/**
+ * @param {string|undefined} dbString
+ * @returns {DbConfig|undefined}
+ */
+function parseDBString (dbString) {
+  if (!dbString || typeof dbString !== 'string') {
+    return
+  }
+
+  const sqlServerConfig = parseSqlServerConnectionString(dbString)
+  if (sqlServerConfig) {
+    return sqlServerConfig
+  }
+
+  try {
+    const url = new URL(dbString)
+    return normalizeDbConfig({
+      user: url.username,
+      password: url.password,
+      host: url.hostname,
+      port: url.port,
+      database: url.pathname?.slice(1) || undefined,
+    })
+  } catch {}
+}
+
+/**
+ * @param {string} dbString
+ * @returns {DbConfig|undefined}
+ */
+function parseSqlServerConnectionString (dbString) {
+  if (!dbString.startsWith('sqlserver://')) {
+    return
+  }
+  const segments = dbString.slice(12).split(';').filter(Boolean)
+  if (!segments.length) {
+    return
+  }
+
+  let hostPart = segments.shift()
+  let user
+  let password
+  if (hostPart?.includes('@')) {
+    const [userInfo, hostInfo] = hostPart.split('@')
+    hostPart = hostInfo
+    ;[user, password] = userInfo.split(':')
+  }
+
+  let database
+  for (const segment of segments) {
+    const [rawKey, ...rawValue] = segment.split('=')
+    const value = rawValue.join('=').trim()
+    const key = rawKey?.trim().toLowerCase()
+    if (!key || !value) {
+      continue
+    }
+    if (key === 'database' || key === 'databasename' || key === 'db') database = value
+    else if (key === 'user' || key === 'username' || key === 'uid') user = value
+    else if (key === 'password' || key === 'pwd') password = value
+  }
+
+  const [host, port] = hostPart?.split(':') ?? []
+
+  return normalizeDbConfig({ user, password, host, port, database })
+}

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

@@ -0,0 +1,29 @@
+'use strict'
+
+const { channel } = require('dc-polyfill')
+const shimmer = require('../../datadog-shimmer')
+
+const startSetUncaughtExceptionCaptureCallback = channel('datadog:process:setUncaughtExceptionCaptureCallback:start')
+
+if (process.setUncaughtExceptionCaptureCallback) {
+  let currentCallback
+
+  shimmer.wrap(process, 'setUncaughtExceptionCaptureCallback',
+    function wrapSetUncaughtExceptionCaptureCallback (originalSetUncaughtExceptionCaptureCallback) {
+      return function setUncaughtExceptionCaptureCallback (newCallback) {
+        if (startSetUncaughtExceptionCaptureCallback.hasSubscribers) {
+          const abortController = new AbortController()
+          startSetUncaughtExceptionCaptureCallback.publish({ newCallback, currentCallback, abortController })
+          if (abortController.signal.aborted) {
+            return
+          }
+        }
+
+        const result = originalSetUncaughtExceptionCaptureCallback.apply(this, arguments)
+
+        currentCallback = newCallback
+
+        return result
+      }
+    })
+}

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

@@ -0,0 +1,15 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook } = require('./helpers/instrument')
+const { wrapThen } = require('./helpers/promise')
+
+addHook({
+  name: 'promise-js',
+  versions: ['>=0.0.3'],
+}, Promise => {
+  if (Promise !== global.Promise) {
+    shimmer.wrap(Promise.prototype, 'then', wrapThen)
+  }
+  return Promise
+})

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

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

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

@@ -0,0 +1,128 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+const shimmer = require('../../datadog-shimmer')
+const { addHook } = require('./helpers/instrument')
+
+const serializeChannel = dc.channel('apm:protobufjs:serialize-start')
+const deserializeChannel = dc.channel('apm:protobufjs:deserialize-end')
+
+function wrapSerialization (messageClass) {
+  if (messageClass?.encode) {
+    shimmer.wrap(messageClass, 'encode', original => function () {
+      if (!serializeChannel.hasSubscribers) {
+        return original.apply(this, arguments)
+      }
+      serializeChannel.publish({ messageClass: this })
+      return original.apply(this, arguments)
+    })
+  }
+}
+
+function wrapDeserialization (messageClass) {
+  if (messageClass?.decode) {
+    shimmer.wrap(messageClass, 'decode', original => function () {
+      if (!deserializeChannel.hasSubscribers) {
+        return original.apply(this, arguments)
+      }
+      const result = original.apply(this, arguments)
+      deserializeChannel.publish({ messageClass: result })
+      return result
+    })
+  }
+}
+
+function wrapSetup (messageClass) {
+  if (messageClass?.setup) {
+    shimmer.wrap(messageClass, 'setup', original => function () {
+      const result = original.apply(this, arguments)
+
+      wrapSerialization(messageClass)
+      wrapDeserialization(messageClass)
+
+      return result
+    })
+  }
+}
+
+function wrapProtobufClasses (root) {
+  if (!root) {
+    return
+  }
+
+  if (root.decode) {
+    wrapSetup(root)
+  }
+
+  if (root.nestedArray) {
+    for (const subRoot of root.nestedArray) {
+      wrapProtobufClasses(subRoot)
+    }
+  }
+}
+
+function wrapReflection (protobuf) {
+  const reflectionMethods = [
+    {
+      target: protobuf.Root,
+      name: 'fromJSON',
+    },
+    {
+      target: protobuf.Type.prototype,
+      name: 'fromObject',
+    },
+  ]
+
+  for (const method of reflectionMethods) {
+    shimmer.wrap(method.target, method.name, original => function () {
+      const result = original.apply(this, arguments)
+      if (result.nested) {
+        for (const type in result.nested) {
+          wrapSetup(result.nested[type])
+        }
+      }
+      if (result.$type) {
+        wrapSetup(result.$type)
+      }
+      return result
+    })
+  }
+}
+
+function isPromise (obj) {
+  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function'
+}
+
+addHook({
+  name: 'protobufjs',
+  versions: ['>=6.8.0'],
+}, protobuf => {
+  shimmer.wrap(protobuf.Root.prototype, 'load', original => function () {
+    const result = original.apply(this, arguments)
+    if (isPromise(result)) {
+      return result.then(root => {
+        wrapProtobufClasses(root)
+        return root
+      })
+    }
+    // If result is not a promise, directly wrap the protobuf classes
+    wrapProtobufClasses(result)
+    return result
+  })
+
+  shimmer.wrap(protobuf.Root.prototype, 'loadSync', original => function () {
+    const root = original.apply(this, arguments)
+    wrapProtobufClasses(root)
+    return root
+  })
+
+  shimmer.wrap(protobuf, 'Type', Original => function () {
+    const typeInstance = new Original(...arguments)
+    wrapSetup(typeInstance)
+    return typeInstance
+  })
+
+  wrapReflection(protobuf)
+
+  return protobuf
+})

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

@@ -0,0 +1,23 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook } = require('./helpers/instrument')
+
+const pugCompileCh = channel('datadog:pug:compile:start')
+
+function wrapCompile (compile) {
+  return function wrappedCompile (source) {
+    if (pugCompileCh.hasSubscribers) {
+      pugCompileCh.publish({ source })
+    }
+
+    return compile.apply(this, arguments)
+  }
+}
+
+addHook({ name: 'pug', versions: ['>=2.0.4'] }, compiler => {
+  shimmer.wrap(compiler, 'compile', wrapCompile)
+  shimmer.wrap(compiler, 'compileClientWithDependenciesTracked', wrapCompile)
+
+  return compiler
+})

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

@@ -0,0 +1,21 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook } = require('./helpers/instrument')
+const { wrapThen } = require('./helpers/promise')
+
+addHook({
+  name: 'q',
+  versions: ['1'],
+}, Q => {
+  shimmer.wrap(Q.makePromise.prototype, 'then', wrapThen)
+  return Q
+})
+
+addHook({
+  name: 'q',
+  versions: ['>=2'],
+}, Q => {
+  shimmer.wrap(Q.Promise.prototype, 'then', wrapThen)
+  return Q
+})

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

@@ -0,0 +1,161 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+
+const startCh = channel('apm:redis:command:start')
+const finishCh = channel('apm:redis:command:finish')
+const errorCh = channel('apm:redis:command:error')
+
+let createClientUrl
+
+function wrapAddCommand (addCommand) {
+  return function (command) {
+    if (!startCh.hasSubscribers) {
+      return addCommand.apply(this, arguments)
+    }
+
+    const name = command[0]
+    const args = command.slice(1)
+
+    const ctx = getStartCtx(this, name, args, this._url)
+    return startCh.runStores(ctx, () => {
+      const res = addCommand.apply(this, arguments)
+
+      res.then(() => finish(finishCh, errorCh, ctx), err => finish(finishCh, errorCh, ctx, err))
+
+      return res
+    })
+  }
+}
+
+function wrapCommandQueueClass (cls) {
+  const ret = class RedisCommandQueue extends cls {
+    constructor (...args) {
+      super(...args)
+      if (createClientUrl) {
+        try {
+          const parsed = new URL(createClientUrl)
+          if (parsed) {
+            this._url = { host: parsed.hostname, port: Number(parsed.port) || 6379 }
+          }
+        } catch {
+          // ignore
+        }
+      }
+      this._url = this._url || { host: 'localhost', port: 6379 }
+    }
+  }
+  return ret
+}
+
+function wrapCreateClient (request) {
+  return function (opts) {
+    createClientUrl = opts && opts.url
+    const ret = request.apply(this, arguments)
+    createClientUrl = undefined
+    return ret
+  }
+}
+
+addHook({ name: '@node-redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1'] }, redis => {
+  redis.default = wrapCommandQueueClass(redis.default)
+  shimmer.wrap(redis.default.prototype, 'addCommand', wrapAddCommand)
+  return redis
+})
+
+addHook({ name: '@node-redis/client', file: 'dist/lib/client/index.js', versions: ['>=1'] }, redis => {
+  shimmer.wrap(redis.default, 'create', wrapCreateClient)
+  return redis
+})
+
+addHook({ name: '@redis/client', file: 'dist/lib/client/index.js', versions: ['>=1.1'] }, redis => {
+  shimmer.wrap(redis.default, 'create', wrapCreateClient)
+  return redis
+})
+
+addHook({ name: '@redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1.1'] }, redis => {
+  redis.default = wrapCommandQueueClass(redis.default)
+  shimmer.wrap(redis.default.prototype, 'addCommand', wrapAddCommand)
+  return redis
+})
+
+addHook({ name: 'redis', versions: ['>=2.6 <4'] }, redis => {
+  shimmer.wrap(redis.RedisClient.prototype, 'internal_send_command', internalSendCommand => function (options) {
+    if (!startCh.hasSubscribers) return internalSendCommand.apply(this, arguments)
+
+    if (!options.callback) return internalSendCommand.apply(this, arguments)
+
+    const ctx = getStartCtx(this, options.command, options.args)
+    return startCh.runStores(ctx, () => {
+      options.callback = wrapCallback(finishCh, errorCh, ctx, options.callback)
+
+      try {
+        return internalSendCommand.apply(this, arguments)
+      } catch (err) {
+        errorCh.publish(err)
+
+        throw err
+      }
+    })
+  })
+  return redis
+})
+
+addHook({ name: 'redis', versions: ['>=0.12 <2.6'] }, redis => {
+  shimmer.wrap(redis.RedisClient.prototype, 'send_command', sendCommand => function (command, args, callback) {
+    if (!startCh.hasSubscribers) {
+      return sendCommand.apply(this, arguments)
+    }
+
+    const ctx = getStartCtx(this, command, args)
+    return startCh.runStores(ctx, () => {
+      if (typeof callback === 'function') {
+        arguments[2] = wrapCallback(finishCh, errorCh, ctx, callback)
+      } else if (Array.isArray(args) && typeof args.at(-1) === 'function') {
+        args[args.length - 1] = wrapCallback(finishCh, errorCh, ctx, args.at(-1))
+      } else {
+        arguments[2] = wrapCallback(finishCh, errorCh, ctx)
+      }
+
+      try {
+        return sendCommand.apply(this, arguments)
+      } catch (err) {
+        ctx.error = err
+        errorCh.publish(ctx)
+
+        throw err
+      }
+    })
+  })
+  return redis
+})
+
+function getStartCtx (client, command, args, url = {}) {
+  return {
+    db: client.selected_db,
+    command,
+    args,
+    connectionOptions: client.connection_options || client.connection_option || client.connectionOption || url,
+  }
+}
+
+function wrapCallback (finishCh, errorCh, ctx, callback) {
+  return shimmer.wrapFunction(callback, callback => function (err) {
+    return finish(finishCh, errorCh, ctx, err, callback, this, arguments)
+  })
+}
+
+function finish (finishCh, errorCh, ctx, error, callback, thisArg, args) {
+  if (error) {
+    ctx.error = error
+    errorCh.publish(ctx)
+  }
+  if (callback) {
+    return finishCh.runStores(ctx, callback, thisArg, ...args)
+  }
+  finishCh.publish(ctx)
+}