dd-trace 5.45.0 → 5.47.0

package/LICENSE-3rdparty.csv

@@ -2,10 +2,10 @@ Component,Origin,License,Copyright
 require,@datadog/libdatadog,Apache license 2.0,Copyright 2024 Datadog Inc.
 require,@datadog/native-appsec,Apache license 2.0,Copyright 2018 Datadog Inc.
 require,@datadog/native-metrics,Apache license 2.0,Copyright 2018 Datadog Inc.
-require,@datadog/native-iast-rewriter,Apache license 2.0,Copyright 2018 Datadog Inc.
 require,@datadog/native-iast-taint-tracking,Apache license 2.0,Copyright 2018 Datadog Inc.
 require,@datadog/pprof,Apache license 2.0,Copyright 2019 Google Inc.
 require,@datadog/sketches-js,Apache license 2.0,Copyright 2020 Datadog Inc.
+require,@datadog/wasm-js-rewriter,Apache license 2.0,Copyright 2018 Datadog Inc.
 require,@opentelemetry/api,Apache license 2.0,Copyright OpenTelemetry Authors
 require,@opentelemetry/core,Apache license 2.0,Copyright OpenTelemetry Authors
 require,@isaacs/ttlcache,ISC,Copyright (c) 2022-2023 - Isaac Z. Schlueter and Contributors
@@ -38,7 +38,6 @@ dev,@eslint/eslintrc,MIT,Copyright OpenJS Foundation and other contributors, <ww
 dev,@eslint/js,MIT,Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
 dev,@msgpack/msgpack,ISC,Copyright 2019 The MessagePack Community
 dev,@stylistic/eslint-plugin-js,MIT,Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
-dev,application-config-path,MIT,Copyright (c) 2015, 2023 Linus Unnebäck
 dev,autocannon,MIT,Copyright 2016 Matteo Collina
 dev,aws-sdk,Apache 2.0,Copyright 2012-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 dev,axios,MIT,Copyright 2014-present Matt Zabriskie

package/ci/init.js

@@ -7,6 +7,8 @@ const isJestWorker = !!process.env.JEST_WORKER_ID
 const isCucumberWorker = !!process.env.CUCUMBER_WORKER_ID
 const isMochaWorker = !!process.env.MOCHA_WORKER_ID
 
+const isPlaywrightWorker = !!process.env.DD_PLAYWRIGHT_WORKER
+
 const packageManagers = [
   'npm',
   'yarn',
@@ -67,6 +69,12 @@ if (isMochaWorker) {
   }
 }
 
+if (isPlaywrightWorker) {
+  options.experimental = {
+    exporter: 'playwright_worker'
+  }
+}
+
 if (shouldInit) {
   tracer.init(options)
   tracer.use('fs', false)

package/ext/exporters.d.ts

@@ -5,7 +5,8 @@ declare const exporters: {
   AGENT_PROXY: 'agent_proxy',
   JEST_WORKER: 'jest_worker',
   CUCUMBER_WORKER: 'cucumber_worker',
-  MOCHA_WORKER: 'mocha_worker'
+  MOCHA_WORKER: 'mocha_worker',
+  PLAYWRIGHT_WORKER: 'playwright_worker'
 }
 
 export = exporters

package/ext/exporters.js

@@ -6,5 +6,6 @@ module.exports = {
   AGENT_PROXY: 'agent_proxy',
   JEST_WORKER: 'jest_worker',
   CUCUMBER_WORKER: 'cucumber_worker',
-  MOCHA_WORKER: 'mocha_worker'
+  MOCHA_WORKER: 'mocha_worker',
+  PLAYWRIGHT_WORKER: 'playwright_worker'
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.45.0",
+  "version": "5.47.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -84,18 +84,18 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@datadog/libdatadog": "^0.5.0",
-    "@datadog/native-appsec": "8.5.1",
-    "@datadog/native-iast-rewriter": "2.8.0",
-    "@datadog/native-iast-taint-tracking": "3.3.0",
-    "@datadog/native-metrics": "^3.1.0",
-    "@datadog/pprof": "5.6.0",
+    "@datadog/libdatadog": "^0.5.1",
+    "@datadog/native-appsec": "8.5.2",
+    "@datadog/native-iast-taint-tracking": "3.3.1",
+    "@datadog/native-metrics": "^3.1.1",
+    "@datadog/pprof": "5.7.1",
     "@datadog/sketches-js": "^2.1.0",
+    "@datadog/wasm-js-rewriter": "4.0.0",
     "@isaacs/ttlcache": "^1.4.1",
     "@opentelemetry/api": ">=1.0.0 <1.9.0",
     "@opentelemetry/core": "^1.14.0",
     "crypto-randomuuid": "^1.0.0",
-    "dc-polyfill": "0.1.6",
+    "dc-polyfill": "0.1.8",
     "ignore": "^5.2.4",
     "import-in-the-middle": "1.13.1",
     "istanbul-lib-coverage": "3.2.0",
@@ -125,7 +125,6 @@
     "@msgpack/msgpack": "^3.0.0-beta3",
     "@stylistic/eslint-plugin-js": "^3.0.1",
     "@types/node": "^16.0.0",
-    "application-config-path": "^0.1.1",
     "autocannon": "^4.5.2",
     "aws-sdk": "^2.1446.0",
     "axios": "^1.8.2",

package/packages/datadog-instrumentations/orchestrion.yml

@@ -0,0 +1,52 @@
+version: 1
+dc_module: dc-polyfill
+instrumentations:
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/runnables/base.js
+    function_query:
+      name: invoke
+      type: method
+      kind: async
+      class: RunnableSequence
+    operator: tracePromise
+    channel_name: "RunnableSequence_invoke"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/runnables/base.js
+    function_query:
+      name: batch
+      type: method
+      kind: async
+      class: RunnableSequence
+    operator: tracePromise
+    channel_name: "RunnableSequence_batch"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/language_models/chat_models.js
+    function_query:
+      name: generate
+      type: method
+      kind: async
+      class: BaseChatModel
+    operator: tracePromise
+    channel_name: "BaseChatModel_generate"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/language_models/llms.js
+    function_query:
+      name: generate
+      type: method
+      kind: async
+    operator: tracePromise
+    channel_name: "BaseLLM_generate"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/embeddings.js
+    function_query:
+      name: constructor
+      type: method
+      kind: sync
+      class: Embeddings
+    operator: traceSync
+    channel_name: "Embeddings_constructor"

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

@@ -267,6 +267,7 @@ function wrapRun (pl, isLatestVersion) {
 
             const failedAttemptAsyncResource = numAttemptToAsyncResource.get(numAttempt)
             const isFirstAttempt = numAttempt++ === 0
+            const isAtrRetry = !isFirstAttempt && isFlakyTestRetriesEnabled
 
             if (promises.hitBreakpointPromise) {
               await promises.hitBreakpointPromise
@@ -274,7 +275,7 @@ function wrapRun (pl, isLatestVersion) {
 
             failedAttemptAsyncResource.runInAsyncScope(() => {
               // the current span will be finished and a new one will be created
-              testRetryCh.publish({ isFirstAttempt, error })
+              testRetryCh.publish({ isFirstAttempt, error, isAtrRetry })
             })
 
             const newAsyncResource = new AsyncResource('bound-anonymous-fn')

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -111,6 +111,7 @@ module.exports = {
   pino: () => require('../pino'),
   'pino-pretty': () => require('../pino'),
   playwright: () => require('../playwright'),
+  'playwright-core': () => require('../playwright'),
   'promise-js': () => require('../promise-js'),
   promise: () => require('../promise'),
   protobufjs: () => require('../protobufjs'),

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -51,6 +51,7 @@ if (DD_TRACE_DEBUG && DD_TRACE_DEBUG.toLowerCase() !== 'false') {
 }
 
 const seenCombo = new Set()
+const allInstrumentations = {}
 
 // TODO: make this more efficient
 for (const packageName of names) {
@@ -67,6 +68,9 @@ for (const packageName of names) {
     hook = hook.fn
   }
 
+  // get the instrumentation file name to save all hooked versions
+  const instrumentationFileName = parseHookInstrumentationFileName(packageName)
+
   Hook([packageName], hookOptions, (moduleExports, moduleName, moduleBaseDir, moduleVersion) => {
     moduleName = moduleName.replace(pathSepExpr, '/')
 
@@ -105,6 +109,7 @@ for (const packageName of names) {
         let version = moduleVersion
         try {
           version = version || getVersion(moduleBaseDir)
+          allInstrumentations[instrumentationFileName] = allInstrumentations[instrumentationFileName] || false
         } catch (e) {
           log.error('Error getting version for "%s": %s', name, e.message, e)
           continue
@@ -114,6 +119,8 @@ for (const packageName of names) {
         }
 
         if (matchVersion(version, versions)) {
+          allInstrumentations[instrumentationFileName] = true
+
           // Check if the hook already has a set moduleExport
           if (hook[HOOK_SYMBOL].has(moduleExports)) {
             namesAndSuccesses[`${name}@${version}`] = true
@@ -143,7 +150,8 @@ for (const packageName of names) {
     for (const nameVersion of Object.keys(namesAndSuccesses)) {
       const [name, version] = nameVersion.split('@')
       const success = namesAndSuccesses[nameVersion]
-      if (!success && !seenCombo.has(nameVersion)) {
+      // we check allVersions to see if any version of the integration was successfully instrumented
+      if (!success && !seenCombo.has(nameVersion) && !allInstrumentations[instrumentationFileName]) {
         telemetry('abort.integration', [
           `integration:${name}`,
           `integration_version:${version}`
@@ -171,6 +179,38 @@ function filename (name, file) {
   return [name, file].filter(val => val).join('/')
 }
 
+// This function captures the instrumentation file name for a given package by parsing the hook require
+// function given the module name. It is used to ensure that instrumentations such as redis
+// that have several different modules being hooked, ie: 'redis' main package, and @redis/client submodule
+// return a consistent instrumentation name. This is used later to ensure that atleast some portion of
+// the integration was successfully instrumented. Prevents incorrect `Found incompatible integration version: ` messages
+// Example:
+//                  redis -> "() => require('../redis')" -> redis
+//          @redis/client -> "() => require('../redis')" -> redis
+//
+function parseHookInstrumentationFileName (packageName) {
+  let hook = hooks[packageName]
+  if (hook.fn) {
+    hook = hook.fn
+  }
+  const hookString = hook.toString()
+
+  const regex = /require\('([^']*)'\)/
+  const match = hookString.match(regex)
+
+  // try to capture the hook require file location.
+  if (match && match[1]) {
+    let moduleName = match[1]
+    // Remove leading '../' if present
+    if (moduleName.startsWith('../')) {
+      moduleName = moduleName.substring(3)
+    }
+    return moduleName
+  }
+
+  return null
+}
+
 module.exports = {
   filename,
   pathSepExpr,

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

@@ -399,10 +399,11 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
         let attemptToFixPassed = false
         let failedAllTests = false
+        let isAttemptToFix = false
         if (this.isTestManagementTestsEnabled) {
           const testName = getJestTestName(event.test)
           const originalTestName = removeAttemptToFixStringFromTestName(testName)
-          const isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(originalTestName)
+          isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(originalTestName)
           if (isAttemptToFix) {
             if (attemptToFixRetriedTestsStatuses.has(originalTestName)) {
               attemptToFixRetriedTestsStatuses.get(originalTestName).push(status)
@@ -423,6 +424,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           }
         }
 
+        let isEfdRetry = false
         // We'll store the test statuses of the retries
         if (this.isKnownTestsEnabled) {
           const testName = getJestTestName(event.test)
@@ -431,6 +433,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           if (isNewTest) {
             if (newTestsTestStatuses.has(originalTestName)) {
               newTestsTestStatuses.get(originalTestName).push(status)
+              isEfdRetry = true
             } else {
               newTestsTestStatuses.set(originalTestName, [status])
             }
@@ -466,12 +469,18 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           })
         }
 
+        let isAtrRetry = false
+        if (this.isFlakyTestRetriesEnabled && event.test?.invocations > 1 && !isAttemptToFix && !isEfdRetry) {
+          isAtrRetry = true
+        }
+
         asyncResource.runInAsyncScope(() => {
           testFinishCh.publish({
             status,
             testStartLine: getTestLineStart(event.test.asyncError, this.testSuite),
             attemptToFixPassed,
-            failedAllTests
+            failedAllTests,
+            isAtrRetry
           })
         })
 

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

@@ -1,31 +1,24 @@
 'use strict'
-
 const { addHook } = require('./helpers/instrument')
+
 const shimmer = require('../../datadog-shimmer')
 
 const tracingChannel = require('dc-polyfill').tracingChannel
 
-const invokeTracingChannel = tracingChannel('apm:langchain:invoke')
-
-function wrapLangChainPromise (fn, type, namespace = []) {
-  return function () {
-    if (!invokeTracingChannel.start.hasSubscribers) {
-      return fn.apply(this, arguments)
-    }
-
-    // Runnable interfaces have an `lc_namespace` property
-    const ns = this.lc_namespace || namespace
-    const resource = [...ns, this.constructor.name].join('.')
-
-    const ctx = {
-      args: arguments,
-      instance: this,
-      type,
-      resource
+function wrap (obj, name, channelName, namespace) {
+  const channel = tracingChannel(channelName)
+  shimmer.wrap(obj, name, function (original) {
+    return function () {
+      if (!channel.start.hasSubscribers) {
+        return original.apply(this, arguments)
+      }
+      const ctx = { self: this, arguments }
+      if (namespace) {
+        ctx.namespace = namespace
+      }
+      return channel.tracePromise(original, ctx, this, ...arguments)
     }
-
-    return invokeTracingChannel.tracePromise(fn, ctx, this, ...arguments)
-  }
+  })
 }
 
 // langchain compiles into ESM and CommonJS, with ESM being the default and landing in the `.js` files
@@ -35,9 +28,10 @@ const extensions = ['js', 'cjs']
 
 for (const extension of extensions) {
   addHook({ name: '@langchain/core', file: `dist/runnables/base.${extension}`, versions: ['>=0.1'] }, exports => {
-    const RunnableSequence = exports.RunnableSequence
-    shimmer.wrap(RunnableSequence.prototype, 'invoke', invoke => wrapLangChainPromise(invoke, 'chain'))
-    shimmer.wrap(RunnableSequence.prototype, 'batch', batch => wrapLangChainPromise(batch, 'chain'))
+    if (extension === 'cjs') {
+      wrap(exports.RunnableSequence.prototype, 'invoke', 'orchestrion:@langchain/core:RunnableSequence_invoke')
+      wrap(exports.RunnableSequence.prototype, 'batch', 'orchestrion:@langchain/core:RunnableSequence_batch')
+    }
     return exports
   })
 
@@ -46,51 +40,53 @@ for (const extension of extensions) {
     file: `dist/language_models/chat_models.${extension}`,
     versions: ['>=0.1']
   }, exports => {
-    const BaseChatModel = exports.BaseChatModel
-    shimmer.wrap(
-      BaseChatModel.prototype,
-      'generate',
-      generate => wrapLangChainPromise(generate, 'chat_model')
-    )
+    if (extension === 'cjs') {
+      wrap(exports.BaseChatModel.prototype, 'generate', 'orchestrion:@langchain/core:BaseChatModel_generate')
+    }
     return exports
   })
 
   addHook({ name: '@langchain/core', file: `dist/language_models/llms.${extension}`, versions: ['>=0.1'] }, exports => {
-    const BaseLLM = exports.BaseLLM
-    shimmer.wrap(BaseLLM.prototype, 'generate', generate => wrapLangChainPromise(generate, 'llm'))
+    if (extension === 'cjs') {
+      wrap(exports.BaseLLM.prototype, 'generate', 'orchestrion:@langchain/core:BaseLLM_generate')
+    }
     return exports
   })
 
   addHook({ name: '@langchain/core', file: `dist/embeddings.${extension}`, versions: ['>=0.1'] }, exports => {
-    // we cannot patch the prototype of the Embeddings class directly
-    // this is because the "abstract class Embeddings" is transpiled from TypeScript to not include abstract functions
-    // thus, we patch the exported class directly instead instead.
+    if (extension === 'cjs') {
+      shimmer.wrap(exports, 'Embeddings', Embeddings => {
+        return class extends Embeddings {
+          constructor (...args) {
+            super(...args)
+
+            const namespace = ['langchain', 'embeddings']
 
-    shimmer.wrap(exports, 'Embeddings', Embeddings => {
-      return class extends Embeddings {
-        constructor (...args) {
-          super(...args)
+            if (this.constructor.name === 'OpenAIEmbeddings') {
+              namespace.push('openai')
+            }
 
+            wrap(this, 'embedQuery', 'apm:@langchain/core:Embeddings_embedQuery', namespace)
+            wrap(this, 'embedDocuments', 'apm:@langchain/core:Embeddings_embedDocuments', namespace)
+          }
+        }
+      })
+    } else {
+      const channel = tracingChannel('orchestrion:@langchain/core:Embeddings_constructor')
+      channel.subscribe({
+        end (ctx) {
+          const { self } = ctx
           const namespace = ['langchain', 'embeddings']
 
-          // when originally implemented, we only wrapped OpenAI embeddings
-          // these embeddings had the resource name of `langchain.embeddings.openai.OpenAIEmbeddings`
-          // we need to make sure `openai` is appended to the resource name until a new tracer major version
-          if (this.constructor.name === 'OpenAIEmbeddings') {
+          if (self.constructor.name === 'OpenAIEmbeddings') {
             namespace.push('openai')
           }
 
-          shimmer.wrap(this, 'embedQuery', embedQuery => wrapLangChainPromise(embedQuery, 'embedding', namespace))
-          shimmer.wrap(this, 'embedDocuments',
-            embedDocuments => wrapLangChainPromise(embedDocuments, 'embedding', namespace))
+          wrap(self, 'embedQuery', 'apm:@langchain/core:Embeddings_embedQuery', namespace)
+          wrap(self, 'embedDocuments', 'apm:@langchain/core:Embeddings_embedDocuments', namespace)
         }
-
-        static [Symbol.hasInstance] (instance) {
-          return instance instanceof Embeddings
-        }
-      }
-    })
-
+      })
+    }
     return exports
   })
 }

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

@@ -153,6 +153,18 @@ function wrapPoolMethod (createConnection) {
   }
 }
 
+function wrapPoolGetConnectionMethod (getConnection) {
+  return function wrappedGetConnection () {
+    const cb = arguments[arguments.length - 1]
+    if (typeof cb !== 'function') return getConnection.apply(this, arguments)
+
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
+    arguments[arguments.length - 1] = callbackResource.bind(cb)
+
+    return getConnection.apply(this, arguments)
+  }
+}
+
 const name = 'mariadb'
 
 addHook({ name, file: 'lib/cmd/query.js', versions: ['>=3'] }, (Query) => {
@@ -163,6 +175,13 @@ addHook({ name, file: 'lib/cmd/execute.js', versions: ['>=3'] }, (Execute) => {
   return wrapCommand(Execute)
 })
 
+// in 3.4.1 getConnection method start to use callbacks instead of promises
+addHook({ name, file: 'lib/pool.js', versions: ['>=3.4.1'] }, (Pool) => {
+  shimmer.wrap(Pool.prototype, 'getConnection', wrapPoolGetConnectionMethod)
+
+  return Pool
+})
+
 addHook({ name, file: 'lib/pool.js', versions: ['>=3'] }, (Pool) => {
   shimmer.wrap(Pool.prototype, '_createConnection', wrapPoolMethod)
 

package/packages/datadog-instrumentations/src/mocha/main.js

@@ -417,7 +417,7 @@ addHook({
 
     this.on('test end', getOnTestEndHandler(config))
 
-    this.on('retry', getOnTestRetryHandler())
+    this.on('retry', getOnTestRetryHandler(config))
 
     // If the hook passes, 'hook end' will be emitted. Otherwise, 'fail' will be emitted
     this.on('hook end', getOnHookEndHandler())

package/packages/datadog-instrumentations/src/mocha/utils.js

@@ -286,6 +286,9 @@ function getOnTestEndHandler (config) {
     }
 
     const isAttemptToFixRetry = test._ddIsAttemptToFix && testStatuses.length > 1
+    const isAtrRetry = config.isFlakyTestRetriesEnabled &&
+      !test._ddIsAttemptToFix &&
+      !test._ddIsEfdRetry
 
     // if there are afterEach to be run, we don't finish the test yet
     if (asyncResource && !getAfterEachHooks(test).length) {
@@ -296,7 +299,8 @@ function getOnTestEndHandler (config) {
           isLastRetry: getIsLastRetry(test),
           hasFailedAllRetries,
           attemptToFixPassed,
-          isAttemptToFixRetry
+          isAttemptToFixRetry,
+          isAtrRetry
         })
       })
     }
@@ -364,14 +368,18 @@ function getOnFailHandler (isMain) {
   }
 }
 
-function getOnTestRetryHandler () {
+function getOnTestRetryHandler (config) {
   return function (test, err) {
     const asyncResource = getTestAsyncResource(test)
     if (asyncResource) {
       const isFirstAttempt = test._currentRetry === 0
       const willBeRetried = test._currentRetry < test._retries
+      const isAtrRetry = !isFirstAttempt &&
+        config.isFlakyTestRetriesEnabled &&
+        !test._ddIsAttemptToFix &&
+        !test._ddIsEfdRetry
       asyncResource.runInAsyncScope(() => {
-        testRetryCh.publish({ isFirstAttempt, err, willBeRetried, test })
+        testRetryCh.publish({ isFirstAttempt, err, willBeRetried, test, isAtrRetry })
       })
     }
     const key = getTestToArKey(test)

package/packages/datadog-instrumentations/src/orchestrion-config/index.js

@@ -0,0 +1,5 @@
+const path = require('path')
+const fs = require('fs')
+
+// TODO this needs to be inlined to prevent issues in bundling
+module.exports = fs.readFileSync(path.join(__dirname, '../../orchestrion.yml'), 'utf8')