@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,80 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
+const { addHook, channel } = require('./helpers/instrument')
+
+const ciSeleniumDriverGetStartCh = channel('ci:selenium:driver:get')
+
+const RUM_STOP_SESSION_SCRIPT = `
+if (window.DD_RUM && window.DD_RUM.stopSession) {
+  window.DD_RUM.stopSession();
+  return true;
+} else {
+  return false;
+}
+`
+const IS_RUM_ACTIVE_SCRIPT = 'return !!window.DD_RUM'
+
+const DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS =
+Number(getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')) || 500
+const DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME = 'datadog-ci-visibility-test-execution-id'
+
+// TODO: can we increase the supported version range?
+addHook({
+  name: 'selenium-webdriver',
+  versions: ['>=4.11.0'],
+}, (seleniumPackage, seleniumVersion) => {
+  // TODO: do not turn this into async. Use promises
+  shimmer.wrap(seleniumPackage.WebDriver.prototype, 'get', get => async function () {
+    if (!ciSeleniumDriverGetStartCh.hasSubscribers) {
+      return get.apply(this, arguments)
+    }
+    let traceId
+    const setTraceId = (inputTraceId) => {
+      traceId = inputTraceId
+    }
+    const getResult = await get.apply(this, arguments)
+
+    const isRumActive = await this.executeScript(IS_RUM_ACTIVE_SCRIPT)
+    const capabilities = await this.getCapabilities()
+
+    ciSeleniumDriverGetStartCh.publish({
+      setTraceId,
+      seleniumVersion,
+      browserName: capabilities.getBrowserName(),
+      browserVersion: capabilities.getBrowserVersion(),
+      isRumActive,
+    })
+
+    if (traceId && isRumActive) {
+      await this.manage().addCookie({
+        name: DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME,
+        value: traceId,
+      })
+    }
+
+    return getResult
+  })
+
+  shimmer.wrap(seleniumPackage.WebDriver.prototype, 'quit', quit => async function () {
+    if (!ciSeleniumDriverGetStartCh.hasSubscribers) {
+      return quit.apply(this, arguments)
+    }
+    const isRumActive = await this.executeScript(RUM_STOP_SESSION_SCRIPT)
+
+    if (isRumActive) {
+      // We'll have time for RUM to flush the events (there's no callback to know when it's done)
+      await new Promise(resolve => {
+        setTimeout(() => {
+          resolve()
+        }, DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS)
+      })
+      await this.manage().deleteCookie(DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME)
+    }
+
+    return quit.apply(this, arguments)
+  })
+
+  return seleniumPackage
+})

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

@@ -0,0 +1,45 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+
+addHook({ name: 'sequelize', versions: ['>=4'], file: ['lib/sequelize.js'] }, Sequelize => {
+  const startCh = channel('datadog:sequelize:query:start')
+  const finishCh = channel('datadog:sequelize:query:finish')
+
+  shimmer.wrap(Sequelize.prototype, 'query', query => {
+    return function (sql, options) {
+      if (!startCh.hasSubscribers) {
+        return query.apply(this, arguments)
+      }
+
+      let dialect
+      if (this.options && this.options.dialect) {
+        dialect = this.options.dialect
+      } else if (this.dialect && this.dialect.name) {
+        dialect = this.dialect.name
+      }
+
+      function onFinish (result) {
+        const type = options?.type || 'RAW'
+        if (type === 'RAW' && result?.length > 1) {
+          result = result[0]
+        }
+
+        finishCh.runStores({ result }, () => {})
+      }
+
+      return startCh.runStores({ sql, dialect }, () => {
+        const promise = query.apply(this, arguments)
+        promise.then(onFinish, () => { onFinish() })
+
+        return promise
+      })
+    }
+  })
+
+  return Sequelize
+})

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

@@ -0,0 +1,72 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+
+/**
+ * @description The enum values in this map are not exposed from ShareDB, so the keys are hard-coded here.
+ * The values were derived from: https://github.com/share/sharedb/blob/master/lib/client/connection.js#L196
+ */
+const READABLE_ACTION_NAMES = {
+  hs: 'handshake',
+  qf: 'query-fetch',
+  qs: 'query-subscribe',
+  qu: 'query-unsubscribe',
+  bf: 'bulk-fetch',
+  bs: 'bulk-subscribe',
+  bu: 'bulk-unsubscribe',
+  f: 'fetch',
+  s: 'subscribe',
+  u: 'unsubscribe',
+  op: 'op',
+  nf: 'snapshot-fetch',
+  nt: 'snapshot-fetch-by-ts',
+  p: 'presence-broadcast',
+  pr: 'presence-request',
+  ps: 'presence-subscribe',
+  pu: 'presence-unsubscribe',
+}
+
+addHook({ name: 'sharedb', versions: ['>=1'], file: 'lib/agent.js' }, Agent => {
+  const startCh = channel('apm:sharedb:request:start')
+  const finishCh = channel('apm:sharedb:request:finish')
+  const errorCh = channel('apm:sharedb:request:error')
+
+  shimmer.wrap(Agent.prototype, '_handleMessage', origHandleMessageFn => function (request, callback) {
+    const action = request.a
+    const actionName = getReadableActionName(action)
+
+    const ctx = { actionName, request }
+    return startCh.runStores(ctx, () => {
+      arguments[1] = shimmer.wrapFunction(callback, callback => function (error, res) {
+        if (error) {
+          ctx.error = error
+          errorCh.publish(error)
+        }
+        ctx.res = res
+        return finishCh.runStores(ctx, callback, this, ...arguments)
+      })
+
+      try {
+        return origHandleMessageFn.apply(this, arguments)
+      } catch (error) {
+        ctx.error = error
+        errorCh.publish(ctx)
+
+        throw error
+      }
+    })
+  })
+  return Agent
+})
+
+function getReadableActionName (action) {
+  const actionName = READABLE_ACTION_NAMES[action]
+  if (actionName === undefined) {
+    return action
+  }
+  return actionName
+}

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

@@ -0,0 +1,92 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook } = require('./helpers/instrument')
+
+const checkoutSessionCreateFinishCh = channel('datadog:stripe:checkoutSession:create:finish')
+const paymentIntentCreateFinishCh = channel('datadog:stripe:paymentIntent:create:finish')
+const constructEventFinishCh = channel('datadog:stripe:constructEvent:finish')
+
+function wrapSessionCreate (create) {
+  return function wrappedSessionCreate () {
+    const promise = create.apply(this, arguments)
+
+    if (!checkoutSessionCreateFinishCh.hasSubscribers) return promise
+
+    return promise.then((result) => {
+      checkoutSessionCreateFinishCh.publish(result)
+      return result
+    })
+  }
+}
+
+function wrapPaymentIntentCreate (create) {
+  return function wrappedPaymentIntentCreate () {
+    const promise = create.apply(this, arguments)
+
+    if (!paymentIntentCreateFinishCh.hasSubscribers) return promise
+
+    return promise.then((result) => {
+      paymentIntentCreateFinishCh.publish(result)
+      return result
+    })
+  }
+}
+
+function wrapConstructEvent (constructEvent) {
+  return function wrappedConstructEvent () {
+    const result = constructEvent.apply(this, arguments)
+
+    // no need to check for hasSubscribers,
+    // if it's false, the publish function will be noop
+    constructEventFinishCh.publish(result)
+
+    return result
+  }
+}
+
+function wrapConstructEventAsync (constructEventAsync) {
+  return function wrappedConstructEventAsync () {
+    const promise = constructEventAsync.apply(this, arguments)
+
+    if (!constructEventFinishCh.hasSubscribers) return promise
+
+    return promise.then((result) => {
+      constructEventFinishCh.publish(result)
+      return result
+    })
+  }
+}
+
+function wrapStripe (Stripe) {
+  return function wrappedStripe () {
+    let stripe = Stripe.apply(this, arguments)
+
+    // to support both with and without "new" operator syntax
+    if (this instanceof Stripe) {
+      stripe = this
+    }
+
+    if (typeof stripe.checkout?.sessions?.create === 'function') {
+      shimmer.wrap(stripe.checkout.sessions, 'create', wrapSessionCreate)
+    }
+    if (typeof stripe.paymentIntents?.create === 'function') {
+      shimmer.wrap(stripe.paymentIntents, 'create', wrapPaymentIntentCreate)
+    }
+    if (typeof stripe.webhooks?.constructEvent === 'function') {
+      shimmer.wrap(stripe.webhooks, 'constructEvent', wrapConstructEvent)
+    }
+    if (typeof stripe.webhooks?.constructEventAsync === 'function') {
+      shimmer.wrap(stripe.webhooks, 'constructEventAsync', wrapConstructEventAsync)
+    }
+
+    return stripe
+  }
+}
+
+addHook({
+  name: 'stripe',
+  versions: ['9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '>=20.0.0'],
+}, Stripe => {
+  return shimmer.wrapFunction(Stripe, wrapStripe)
+})

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

@@ -0,0 +1,63 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+
+addHook({ name: 'tedious', versions: ['>=1.0.0'] }, tedious => {
+  const startCh = channel('apm:tedious:request:start')
+  const finishCh = channel('apm:tedious:request:finish')
+  const errorCh = channel('apm:tedious:request:error')
+  shimmer.wrap(tedious.Connection.prototype, 'makeRequest', makeRequest => function (request) {
+    if (!startCh.hasSubscribers) {
+      return makeRequest.apply(this, arguments)
+    }
+
+    const [queryOrProcedure, queryParent, queryField] = getQueryOrProcedure(request)
+
+    if (!queryOrProcedure) {
+      return makeRequest.apply(this, arguments)
+    }
+
+    const connectionConfig = this.config
+    const ctx = { queryOrProcedure, connectionConfig }
+
+    return startCh.runStores(ctx, () => {
+      queryParent[queryField] = ctx.sql
+
+      const cb = request.callback
+      request.callback = function (error, ...args) {
+        if (error) {
+          ctx.error = error
+          errorCh.publish(ctx)
+        }
+        return finishCh.runStores(ctx, cb, this, error, ...args)
+      }
+
+      try {
+        return makeRequest.apply(this, arguments)
+      } catch (error) {
+        ctx.error = error
+        errorCh.publish(ctx)
+
+        throw error
+      }
+    })
+  })
+
+  return tedious
+})
+
+// returns [queryOrProcedure, parentObjectToSet, propertyNameToSet]
+function getQueryOrProcedure (request) {
+  if (!request.parameters) return [null]
+
+  if (request.parametersByName.statement) {
+    return [request.parametersByName.statement.value, request.parametersByName.statement, 'value']
+  } else if (request.parametersByName.stmt) {
+    return [request.parametersByName.stmt.value, request.parametersByName.stmt, 'value']
+  }
+  return [request.sqlTextOrProcedure, request, 'sqlTextOrProcedure']
+}

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

@@ -0,0 +1,29 @@
+'use strict'
+
+const tracingChannel = require('dc-polyfill').tracingChannel
+
+const shimmer = require('../../datadog-shimmer')
+const satisfies = require('../../../vendor/dist/semifies')
+const {
+  addHook,
+} = require('./helpers/instrument')
+const { createWrapFetch } = require('./helpers/fetch')
+
+const ch = tracingChannel('apm:undici:fetch')
+
+// Undici 5.0.x has a bug where fetch doesn't preserve AggregateError in the error cause chain
+// Use native DC only for versions where error handling works correctly
+const NATIVE_DC_VERSION = '>=4.7.0 <5.0.0 || >=5.1.0'
+
+addHook({
+  name: 'undici',
+  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)) {
+    return undici
+  }
+
+  // For older versions or those with buggy error handling, wrap fetch
+  return shimmer.wrap(undici, 'fetch', createWrapFetch(undici.Request, ch))
+})

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

@@ -0,0 +1,80 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel } = require('./helpers/instrument')
+const names = ['url', 'node:url']
+
+const parseFinishedChannel = channel('datadog:url:parse:finish')
+const urlGetterChannel = channel('datadog:url:getter:finish')
+const instrumentedGetters = ['host', 'origin', 'hostname']
+
+addHook({ name: names }, function (url) {
+  shimmer.wrap(url, 'parse', (parse) => {
+    return function wrappedParse (input) {
+      const parsedValue = parse.apply(this, arguments)
+      if (!parseFinishedChannel.hasSubscribers) return parsedValue
+
+      parseFinishedChannel.publish({
+        input,
+        parsed: parsedValue,
+        isURL: false,
+      })
+
+      return parsedValue
+    }
+  })
+
+  const URLPrototype = url.URL.prototype.constructor.prototype
+  for (const property of instrumentedGetters) {
+    shimmer.wrap(URLPrototype, property, function (originalGet) {
+      return function get () {
+        const result = originalGet.call(this)
+        if (!urlGetterChannel.hasSubscribers) return result
+
+        const context = { urlObject: this, result, property }
+        urlGetterChannel.publish(context)
+
+        return context.result
+      }
+    })
+  }
+
+  shimmer.wrap(url, 'URL', (URL) => {
+    return class extends URL {
+      constructor (input, base) {
+        super(...arguments)
+
+        if (!parseFinishedChannel.hasSubscribers) return
+
+        parseFinishedChannel.publish({
+          input,
+          base,
+          parsed: this,
+          isURL: true,
+        })
+      }
+
+      static [Symbol.hasInstance] (instance) {
+        return instance instanceof URL
+      }
+    }
+  })
+
+  if (url.URL.parse) {
+    shimmer.wrap(url.URL, 'parse', (parse) => {
+      return function wrappedParse (input, base) {
+        const parsedValue = parse.apply(this, arguments)
+        if (!parseFinishedChannel.hasSubscribers) return parsedValue
+
+        parseFinishedChannel.publish({
+          input,
+          base,
+          parsed: parsedValue,
+          isURL: true,
+        })
+
+        return parsedValue
+      }
+    })
+  }
+})