dd-trace 5.84.0 → 5.86.0

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

@@ -1,129 +1,270 @@
 'use strict'
 
-const tracingChannel = require('dc-polyfill').tracingChannel
-
+const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
 const { channel, addHook } = require('./helpers/instrument')
-const prismaEngineStart = channel('apm:prisma:engine:start')
-const clientCH = tracingChannel('apm:prisma:client')
+const prismaHelperInit = channel('apm:prisma:helper:init')
 
-const allowedClientSpanOperations = new Set([
-  'operation',
-  'serialize',
-  'transaction'
-])
+/**
+ * @typedef {object} EnvValue
+ * @property {string|undefined} [value]
+ * @property {string|null|undefined} [fromEnvVar]
+ */
 
-class DatadogTracingHelper {
-  dbConfig = null
+/**
+ * @typedef {object} DatasourceConfig
+ * @property {string|EnvValue|undefined} [url]
+ */
 
-  constructor (dbConfig = null) {
-    this.dbConfig = dbConfig
-  }
+/**
+ * @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]
+ */
 
-  isEnabled () {
-    return true
-  }
+/**
+ * @typedef {object} DbConfig
+ * @property {string|undefined} [user]
+ * @property {string|undefined} [password]
+ * @property {string|undefined} [host]
+ * @property {string|number|undefined} [port]
+ * @property {string|undefined} [database]
+ */
 
-  // needs a sampled tracecontext to generate engine spans
-  getTraceParent (context) {
-    // TODO: Fix the id
-    return '00-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-bbbbbbbbbbbbbbbb-01' // valid sampled traceparent
-  }
+/**
+ * @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]
+ */
 
-  dispatchEngineSpans (spans) {
-    for (const span of spans) {
-      if (span.parentId === null) {
-        prismaEngineStart.publish({ engineSpan: span, allEngineSpans: spans, dbConfig: this.dbConfig })
-      }
-    }
-  }
+/**
+ * @typedef {object} Adapter
+ * @property {AdapterConfig|undefined} [config]
+ * @property {{ options?: AdapterConfig }|undefined} [externalPool]
+ */
 
-  getActiveContext () {
-    // TODO: Fix context
-  }
+/**
+ * @typedef {object} PrismaClientConfig
+ * @property {string|undefined} [datasourceUrl]
+ * @property {Record<string, { url?: string }>|undefined} [datasources]
+ * @property {Adapter|undefined} [adapter]
+ */
 
-  runInChildSpan (options, callback) {
-    if (typeof options === 'string') {
-      options = {
-        name: options
-      }
-    }
+/**
+ * @typedef {object} PrismaHelperCtx
+ * @property {DbConfig} [dbConfig]
+ * @property {import('../../datadog-plugin-prisma/src/datadog-tracing-helper')} [helper]
+ */
 
-    if (allowedClientSpanOperations.has(options.name)) {
-      const ctx = {
-        resourceName: options.name,
-        attributes: options.attributes || {}
-      }
+/**
+ * @param {string|EnvValue|undefined} envValue
+ * @returns {string|undefined}
+ */
+function resolveEnvValue (envValue) {
+  return typeof envValue === 'object' && envValue
+    ? (envValue.value || getEnvironmentVariable(envValue.fromEnvVar ?? ''))
+    : envValue
+}
 
-      if (options.name !== 'serialize') {
-        return clientCH.tracePromise(callback, ctx, this, ...arguments)
-      }
+/**
+ * @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')
+}
 
-      return clientCH.traceSync(callback, ctx, this, ...arguments)
-    }
-    return callback()
+/**
+ * @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
   }
 
-  setDbString (dbConfig) {
-    this.dbConfig = dbConfig
+  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) => {
-  const originalGetPrismaClient = runtime.getPrismaClient
+  /**
+   * @typedef {{ getPrismaClient?: (config: PrismaRuntimeConfig, ...args: unknown[]) => Function }} PrismaRuntime
+   */
+  const prismaRuntime = /** @type {PrismaRuntime} */ (runtime)
+  const originalGetPrismaClient = prismaRuntime.getPrismaClient
 
-  if (!originalGetPrismaClient) return runtime
-  const datadogTracingHelper = new DatadogTracingHelper()
+  if (!originalGetPrismaClient) {
+    return runtime
+  }
 
+  /**
+   * @param {PrismaRuntimeConfig|undefined} config
+   */
   const wrappedGetPrismaClient = function (config) {
-    const datasources = config.inlineDatasources?.db.url?.value
-    if (datasources) {
-      const dbConfig = parseDBString(datasources)
-      datadogTracingHelper.setDbString(dbConfig)
-    }
+    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)
-        this._tracingHelper = datadogTracingHelper
-        this._engine.tracingHelper = datadogTracingHelper
+        /**
+         * @type {PrismaHelperCtx}
+         */
+        const prismaHelperCtx = {
+          dbConfig: resolveClientDbConfig(clientConfig, datasourceName, runtimeDbConfig),
+        }
+        prismaHelperInit.publish(prismaHelperCtx)
+
+        const helper = prismaHelperCtx.helper
+        this._tracingHelper = helper
+        this._engine.tracingHelper = helper
       }
     }
   }
 
   if (isIitm) {
-    runtime.getPrismaClient = wrappedGetPrismaClient
+    prismaRuntime.getPrismaClient = wrappedGetPrismaClient
     return runtime
   }
 
-  return new Proxy(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.*' }
+  { name: '@prisma/client', versions: ['>=7.0.0'], filePattern: 'runtime/client.*' },
 ]
 
-prismaConfigs.forEach(config => {
+for (const config of prismaConfigs) {
   addHook(config, prismaHook)
-})
+}
 
+/**
+ * @param {string|undefined} dbString
+ * @returns {DbConfig|undefined}
+ */
 function parseDBString (dbString) {
-  const url = new URL(dbString)
-  const dbConfig = {
-    user: url.username,
-    password: url.password,
-    host: url.hostname,
-    port: url.port,
-    database: url.pathname.slice(1) // Remove leading slash
+  if (!dbString || typeof dbString !== 'string') {
+    return
+  }
+
+  const sqlServerConfig = parseSqlServerConnectionString(dbString)
+  if (sqlServerConfig) {
+    return sqlServerConfig
   }
-  return dbConfig
+
+  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/promise-js.js

@@ -6,7 +6,7 @@ const { wrapThen } = require('./helpers/promise')
 
 addHook({
   name: 'promise-js',
-  versions: ['>=0.0.3']
+  versions: ['>=0.0.3'],
 }, Promise => {
   if (Promise !== global.Promise) {
     shimmer.wrap(Promise.prototype, 'then', wrapThen)

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

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

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

@@ -65,15 +65,15 @@ function wrapReflection (protobuf) {
   const reflectionMethods = [
     {
       target: protobuf.Root,
-      name: 'fromJSON'
+      name: 'fromJSON',
     },
     {
       target: protobuf.Type.prototype,
-      name: 'fromObject'
-    }
+      name: 'fromObject',
+    },
   ]
 
-  reflectionMethods.forEach(method => {
+  for (const method of reflectionMethods) {
     shimmer.wrap(method.target, method.name, original => function () {
       const result = original.apply(this, arguments)
       if (result.nested) {
@@ -86,7 +86,7 @@ function wrapReflection (protobuf) {
       }
       return result
     })
-  })
+  }
 }
 
 function isPromise (obj) {
@@ -95,7 +95,7 @@ function isPromise (obj) {
 
 addHook({
   name: 'protobufjs',
-  versions: ['>=6.8.0']
+  versions: ['>=6.8.0'],
 }, protobuf => {
   shimmer.wrap(protobuf.Root.prototype, 'load', original => function () {
     const result = original.apply(this, arguments)

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

@@ -6,7 +6,7 @@ const { wrapThen } = require('./helpers/promise')
 
 addHook({
   name: 'q',
-  versions: ['1']
+  versions: ['1'],
 }, Q => {
   shimmer.wrap(Q.makePromise.prototype, 'then', wrapThen)
   return Q
@@ -14,7 +14,7 @@ addHook({
 
 addHook({
   name: 'q',
-  versions: ['>=2']
+  versions: ['>=2'],
 }, Q => {
   shimmer.wrap(Q.Promise.prototype, 'then', wrapThen)
   return Q

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

@@ -3,7 +3,7 @@
 const shimmer = require('../../datadog-shimmer')
 const {
   channel,
-  addHook
+  addHook,
 } = require('./helpers/instrument')
 
 const startCh = channel('apm:redis:command:start')
@@ -139,7 +139,7 @@ function getStartCtx (client, command, args, url = {}) {
     db: client.selected_db,
     command,
     args,
-    connectionOptions: client.connection_options || client.connection_option || client.connectionOption || url
+    connectionOptions: client.connection_options || client.connection_option || client.connectionOption || url,
   }
 }
 

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

@@ -3,7 +3,7 @@
 const shimmer = require('../../datadog-shimmer')
 const {
   channel,
-  addHook
+  addHook,
 } = require('./helpers/instrument')
 
 const circularBufferConstructor = Symbol('circularBufferConstructor')
@@ -100,16 +100,16 @@ addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/connection.js' }, Connecti
     if (eventName === 'disconnected') {
       const error = obj.error || this.saved_error
       if (this[inFlightDeliveries]) {
-        this[inFlightDeliveries].forEach(delivery => {
+        for (const delivery of this[inFlightDeliveries]) {
           const ctx = contexts.get(delivery)
 
-          if (!ctx) return
+          if (!ctx) continue
 
           ctx.error = error
           errorReceiveCh.publish(ctx)
           exports.beforeFinish(delivery, null)
           finishReceiveCh.publish(ctx)
-        })
+        }
       }
     }
     return dispatch.apply(this, arguments)
@@ -195,7 +195,7 @@ function patchCircularBuffer (proto, Session) {
           }
         }
       }
-    }
+    },
   })
 }
 

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

@@ -15,7 +15,7 @@ const {
   extractMountPaths,
   getRouteFullPaths,
   wrapRouteMethodsAndPublish,
-  collectRoutesFromRouter
+  collectRoutesFromRouter,
 } = require('./helpers/router-helper')
 
 function isFastStar (layer, matchers) {
@@ -93,13 +93,13 @@ function createWrapRouterMethod (name) {
       setLayerMatchers(layer, matchers)
 
       if (layer.route) {
-        METHODS.forEach(method => {
+        for (const method of METHODS) {
           if (typeof layer.route.stack === 'function') {
             layer.route.stack = [{ handle: layer.route.stack }]
           }
 
           layer.route[method] = wrapMethod(layer.route[method])
-        })
+        }
       }
     }
   }
@@ -131,7 +131,7 @@ function createWrapRouterMethod (name) {
         return !isFastStar(layer, matchers) &&
           !isFastSlash(layer, matchers) &&
           cachedPathToRegExp(pattern).test(layer.path)
-      }
+      },
     }))
   }
 
@@ -272,7 +272,7 @@ function wrapHandleRequest (original) {
         req,
         res,
         params: req?.params,
-        abortController
+        abortController,
       })
 
       if (abortController.signal.aborted) return
@@ -283,7 +283,7 @@ function wrapHandleRequest (original) {
 }
 
 addHook({
-  name: 'router', file: 'lib/layer.js', versions: ['>=2']
+  name: 'router', file: 'lib/layer.js', versions: ['>=2'],
 }, Layer => {
   shimmer.wrap(Layer.prototype, 'handleRequest', wrapHandleRequest)
   return Layer
@@ -302,7 +302,7 @@ function wrapParam (original) {
             req,
             res,
             params: req?.params,
-            abortController
+            abortController,
           })
 
           if (abortController.signal.aborted) return
@@ -317,7 +317,7 @@ function wrapParam (original) {
 }
 
 addHook({
-  name: 'router', versions: ['>=2']
+  name: 'router', versions: ['>=2'],
 }, router => {
   shimmer.wrap(router.prototype, 'param', wrapParam)
   return router

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

@@ -23,7 +23,7 @@ const DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME = 'datadog-ci-visibility-tes
 // TODO: can we increase the supported version range?
 addHook({
   name: 'selenium-webdriver',
-  versions: ['>=4.11.0']
+  versions: ['>=4.11.0'],
 }, (seleniumPackage, seleniumVersion) => {
   // TODO: do not turn this into async. Use promises
   shimmer.wrap(seleniumPackage.WebDriver.prototype, 'get', get => async function () {
@@ -44,13 +44,13 @@ addHook({
       seleniumVersion,
       browserName: capabilities.getBrowserName(),
       browserVersion: capabilities.getBrowserVersion(),
-      isRumActive
+      isRumActive,
     })
 
     if (traceId && isRumActive) {
       await this.manage().addCookie({
         name: DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME,
-        value: traceId
+        value: traceId,
       })
     }
 

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

@@ -3,7 +3,7 @@
 const shimmer = require('../../datadog-shimmer')
 const {
   channel,
-  addHook
+  addHook,
 } = require('./helpers/instrument')
 
 addHook({ name: 'sequelize', versions: ['>=4'], file: ['lib/sequelize.js'] }, Sequelize => {

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

@@ -3,7 +3,7 @@
 const shimmer = require('../../datadog-shimmer')
 const {
   channel,
-  addHook
+  addHook,
 } = require('./helpers/instrument')
 
 /**
@@ -27,7 +27,7 @@ const READABLE_ACTION_NAMES = {
   p: 'presence-broadcast',
   pr: 'presence-request',
   ps: 'presence-subscribe',
-  pu: 'presence-unsubscribe'
+  pu: 'presence-unsubscribe',
 }
 
 addHook({ name: 'sharedb', versions: ['>=1'], file: 'lib/agent.js' }, Agent => {

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

@@ -3,7 +3,7 @@
 const shimmer = require('../../datadog-shimmer')
 const {
   channel,
-  addHook
+  addHook,
 } = require('./helpers/instrument')
 
 addHook({ name: 'tedious', versions: ['>=1.0.0'] }, tedious => {

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

@@ -5,7 +5,7 @@ const tracingChannel = require('dc-polyfill').tracingChannel
 const shimmer = require('../../datadog-shimmer')
 const satisfies = require('../../../vendor/dist/semifies')
 const {
-  addHook
+  addHook,
 } = require('./helpers/instrument')
 const { createWrapFetch } = require('./helpers/fetch')
 
@@ -17,7 +17,7 @@ const NATIVE_DC_VERSION = '>=4.7.0 <5.0.0 || >=5.1.0'
 
 addHook({
   name: 'undici',
-  versions: ['^4.4.1', '5', '>=6.0.0']
+  versions: ['^4.4.1', '5', '>=6.0.0'],
 }, (undici, version) => {
   // For versions with working native DC, let the plugin subscribe directly
   if (satisfies(version, NATIVE_DC_VERSION)) {

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

@@ -17,7 +17,7 @@ addHook({ name: names }, function (url) {
       parseFinishedChannel.publish({
         input,
         parsed: parsedValue,
-        isURL: false
+        isURL: false,
       })
 
       return parsedValue
@@ -25,7 +25,7 @@ addHook({ name: names }, function (url) {
   })
 
   const URLPrototype = url.URL.prototype.constructor.prototype
-  instrumentedGetters.forEach(property => {
+  for (const property of instrumentedGetters) {
     shimmer.wrap(URLPrototype, property, function (originalGet) {
       return function get () {
         const result = originalGet.call(this)
@@ -37,7 +37,7 @@ addHook({ name: names }, function (url) {
         return context.result
       }
     })
-  })
+  }
 
   shimmer.wrap(url, 'URL', (URL) => {
     return class extends URL {
@@ -50,7 +50,7 @@ addHook({ name: names }, function (url) {
           input,
           base,
           parsed: this,
-          isURL: true
+          isURL: true,
         })
       }
 
@@ -70,7 +70,7 @@ addHook({ name: names }, function (url) {
           input,
           base,
           parsed: parsedValue,
-          isURL: true
+          isURL: true,
         })
 
         return parsedValue