dd-trace 5.44.0 → 5.46.0

package/LICENSE-3rdparty.csv

@@ -2,7 +2,7 @@ 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/wasm-js-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.

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.44.0",
+  "version": "5.46.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -86,10 +86,10 @@
   "dependencies": {
     "@datadog/libdatadog": "^0.5.0",
     "@datadog/native-appsec": "8.5.1",
-    "@datadog/native-iast-rewriter": "2.8.0",
+    "@datadog/wasm-js-rewriter": "3.1.0",
     "@datadog/native-iast-taint-tracking": "3.3.0",
     "@datadog/native-metrics": "^3.1.0",
-    "@datadog/pprof": "5.6.0",
+    "@datadog/pprof": "5.7.0",
     "@datadog/sketches-js": "^2.1.0",
     "@isaacs/ttlcache": "^1.4.1",
     "@opentelemetry/api": ">=1.0.0 <1.9.0",

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/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/playwright.js

@@ -2,7 +2,11 @@ const satisfies = require('semifies')
 
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
-const { parseAnnotations, getTestSuitePath } = require('../../dd-trace/src/plugins/util/test')
+const {
+  parseAnnotations,
+  getTestSuitePath,
+  PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE
+} = require('../../dd-trace/src/plugins/util/test')
 const log = require('../../dd-trace/src/log')
 
 const testStartCh = channel('ci:playwright:test:start')
@@ -18,6 +22,9 @@ const testManagementTestsCh = channel('ci:playwright:test-management-tests')
 const testSuiteStartCh = channel('ci:playwright:test-suite:start')
 const testSuiteFinishCh = channel('ci:playwright:test-suite:finish')
 
+const workerReportCh = channel('ci:playwright:worker:report')
+const testPageGotoCh = channel('ci:playwright:test:page-goto')
+
 const testToAr = new WeakMap()
 const testSuiteToAr = new Map()
 const testSuiteToTestStatuses = new Map()
@@ -255,21 +262,19 @@ function getTestFullname (test) {
   return names.join(' ')
 }
 
-function testBeginHandler (test, browserName) {
+function testBeginHandler (test, browserName, isMainProcess) {
   const {
     _requireFile: testSuiteAbsolutePath,
-    _type,
     location: {
       line: testSourceLine
-    }
+    },
+    _type
   } = test
 
   if (_type === 'beforeAll' || _type === 'afterAll') {
     return
   }
 
-  const testName = getTestFullname(test)
-
   const isNewTestSuite = !startedSuites.includes(testSuiteAbsolutePath)
 
   if (isNewTestSuite) {
@@ -286,24 +291,31 @@ function testBeginHandler (test, browserName) {
     test.retries = 0
   }
 
-  const testAsyncResource = new AsyncResource('bound-anonymous-fn')
-  testToAr.set(test, testAsyncResource)
-  testAsyncResource.runInAsyncScope(() => {
-    testStartCh.publish({
-      testName,
-      testSuiteAbsolutePath,
-      testSourceLine,
-      browserName,
-      isDisabled: test._ddIsDisabled
+  // this handles tests that do not go through the worker process (because they're skipped)
+  if (isMainProcess) {
+    const testAsyncResource = new AsyncResource('bound-anonymous-fn')
+    testToAr.set(test, testAsyncResource)
+    const testName = getTestFullname(test)
+
+    testAsyncResource.runInAsyncScope(() => {
+      testStartCh.publish({
+        testName,
+        testSuiteAbsolutePath,
+        testSourceLine,
+        browserName,
+        isDisabled: test._ddIsDisabled
+      })
     })
-  })
+  }
 }
-function testEndHandler (test, annotations, testStatus, error, isTimeout) {
+
+function testEndHandler (test, annotations, testStatus, error, isTimeout, isMainProcess) {
+  const { _requireFile: testSuiteAbsolutePath, results, _type } = test
+
   let annotationTags
   if (annotations.length) {
     annotationTags = parseAnnotations(annotations)
   }
-  const { _requireFile: testSuiteAbsolutePath, results, _type } = test
 
   if (_type === 'beforeAll' || _type === 'afterAll') {
     const hookError = formatTestHookError(error, _type, isTimeout)
@@ -324,35 +336,35 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout) {
     testStatuses.push(testStatus)
   }
 
-  let hasFailedAllRetries = false
-  let hasPassedAttemptToFixRetries = false
-
   if (testStatuses.length === testManagementAttemptToFixRetries + 1) {
     if (testStatuses.every(status => status === 'fail')) {
-      hasFailedAllRetries = true
+      test._ddHasFailedAllRetries = true
     } else if (testStatuses.every(status => status === 'pass')) {
-      hasPassedAttemptToFixRetries = true
+      test._ddHasPassedAttemptToFixRetries = true
     }
   }
 
-  const testResult = results[results.length - 1]
-  const testAsyncResource = testToAr.get(test)
-  testAsyncResource.runInAsyncScope(() => {
-    testFinishCh.publish({
-      testStatus,
-      steps: testResult?.steps || [],
-      isRetry: testResult?.retry > 0,
-      error,
-      extraTags: annotationTags,
-      isNew: test._ddIsNew,
-      isAttemptToFix: test._ddIsAttemptToFix,
-      isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
-      isQuarantined: test._ddIsQuarantined,
-      isEfdRetry: test._ddIsEfdRetry,
-      hasFailedAllRetries,
-      hasPassedAttemptToFixRetries
+  // this handles tests that do not go through the worker process (because they're skipped)
+  if (isMainProcess) {
+    const testResult = results[results.length - 1]
+    const testAsyncResource = testToAr.get(test)
+    testAsyncResource.runInAsyncScope(() => {
+      testFinishCh.publish({
+        testStatus,
+        steps: testResult?.steps || [],
+        isRetry: testResult?.retry > 0,
+        error,
+        extraTags: annotationTags,
+        isNew: test._ddIsNew,
+        isAttemptToFix: test._ddIsAttemptToFix,
+        isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
+        isQuarantined: test._ddIsQuarantined,
+        isEfdRetry: test._ddIsEfdRetry,
+        hasFailedAllRetries: test._ddHasFailedAllRetries,
+        hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries
+      })
     })
-  })
+  }
 
   if (testSuiteToTestStatuses.has(testSuiteAbsolutePath)) {
     testSuiteToTestStatuses.get(testSuiteAbsolutePath).push(testStatus)
@@ -416,7 +428,7 @@ function dispatcherHook (dispatcherExport) {
         const { test } = dispatcher._testById.get(params.testId)
         const projects = getProjectsFromDispatcher(dispatcher)
         const browser = getBrowserNameFromProjects(projects, test)
-        testBeginHandler(test, browser)
+        testBeginHandler(test, browser, true)
       } else if (method === 'testEnd') {
         const { test } = dispatcher._testById.get(params.testId)
 
@@ -424,7 +436,14 @@ function dispatcherHook (dispatcherExport) {
         const testResult = results[results.length - 1]
 
         const isTimeout = testResult.status === 'timedOut'
-        testEndHandler(test, params.annotations, STATUS_TO_TEST_STATUS[testResult.status], testResult.error, isTimeout)
+        testEndHandler(
+          test,
+          params.annotations,
+          STATUS_TO_TEST_STATUS[testResult.status],
+          testResult.error,
+          isTimeout,
+          true
+        )
       }
     })
 
@@ -443,13 +462,28 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
       const test = getTestByTestId(dispatcher, testId)
       const projects = getProjectsFromDispatcher(dispatcher)
       const browser = getBrowserNameFromProjects(projects, test)
-      testBeginHandler(test, browser)
+      testBeginHandler(test, browser, false)
     })
     worker.on('testEnd', ({ testId, status, errors, annotations }) => {
       const test = getTestByTestId(dispatcher, testId)
 
       const isTimeout = status === 'timedOut'
-      testEndHandler(test, annotations, STATUS_TO_TEST_STATUS[status], errors && errors[0], isTimeout)
+      testEndHandler(test, annotations, STATUS_TO_TEST_STATUS[status], errors && errors[0], isTimeout, false)
+      // We want to send the ddProperties to the worker
+      worker.process.send({
+        type: 'ddProperties',
+        testId: test.id,
+        properties: {
+          _ddIsDisabled: test._ddIsDisabled,
+          _ddIsQuarantined: test._ddIsQuarantined,
+          _ddIsAttemptToFix: test._ddIsAttemptToFix,
+          _ddIsAttemptToFixRetry: test._ddIsAttemptToFixRetry,
+          _ddIsNew: test._ddIsNew,
+          _ddIsEfdRetry: test._ddIsEfdRetry,
+          _ddHasFailedAllRetries: test._ddHasFailedAllRetries,
+          _ddHasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries
+        }
+      })
     })
 
     return worker
@@ -538,8 +572,8 @@ function runnerHook (runnerExport, playwrightVersion) {
       // because they were skipped
       tests.forEach(test => {
         const browser = getBrowserNameFromProjects(projects, test)
-        testBeginHandler(test, browser)
-        testEndHandler(test, [], 'skip')
+        testBeginHandler(test, browser, true)
+        testEndHandler(test, [], 'skip', null, false, true)
       })
     })
 
@@ -720,3 +754,244 @@ addHook({
 
   return loadUtilsPackage
 })
+
+// main process hook
+addHook({
+  name: 'playwright',
+  file: 'lib/runner/processHost.js',
+  versions: ['>=1.38.0']
+}, (processHostPackage) => {
+  shimmer.wrap(processHostPackage.ProcessHost.prototype, 'startRunner', startRunner => async function () {
+    this._extraEnv = {
+      ...this._extraEnv,
+      // Used to detect that we're in a playwright worker
+      DD_PLAYWRIGHT_WORKER: '1'
+    }
+
+    const res = await startRunner.apply(this, arguments)
+
+    // We add a new listener to `this.process`, which is represents the worker
+    this.process.on('message', (message) => {
+      // These messages are [code, payload]. The payload is test data
+      if (Array.isArray(message) && message[0] === PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE) {
+        workerReportCh.publish(message[1])
+      }
+    })
+
+    return res
+  })
+
+  return processHostPackage
+})
+
+addHook({
+  name: 'playwright-core',
+  file: 'lib/client/page.js',
+  versions: ['>=1.38.0']
+}, (pagePackage) => {
+  shimmer.wrap(pagePackage.Page.prototype, 'goto', goto => async function (url, options) {
+    const response = await goto.apply(this, arguments)
+
+    const page = this
+
+    const isRumActive = await page.evaluate(() => {
+      if (window.DD_RUM && window.DD_RUM.getInternalContext) {
+        return !!window.DD_RUM.getInternalContext()
+      } else {
+        return false
+      }
+    })
+
+    if (isRumActive) {
+      testPageGotoCh.publish({
+        isRumActive,
+        page
+      })
+    }
+
+    return response
+  })
+
+  return pagePackage
+})
+
+// Only in worker
+addHook({
+  name: 'playwright',
+  file: 'lib/worker/workerMain.js',
+  versions: ['>=1.38.0']
+}, (workerPackage) => {
+  // we assume there's only a test running at a time
+  let steps = []
+  const stepInfoByStepId = {}
+
+  shimmer.wrap(workerPackage.WorkerMain.prototype, '_runTest', _runTest => async function (test) {
+    steps = []
+
+    const {
+      _requireFile: testSuiteAbsolutePath,
+      location: {
+        line: testSourceLine
+      }
+    } = test
+    let res
+
+    let testInfo
+    const testName = getTestFullname(test)
+    const browserName = this._project.project.name
+
+    // If test events are created in the worker process I need to stop creating it in the main process
+    // Probably yet another test worker exporter is needed in addition to the ones for mocha, jest and cucumber
+    // it's probably hard to tell that's a playwright worker though, as I don't think there is a specific env variable
+    const testAsyncResource = new AsyncResource('bound-anonymous-fn')
+    // TODO - In the future we may need to implement a mechanism to send test properties
+    // to the worker process before _runTest is called
+    testAsyncResource.runInAsyncScope(() => {
+      testStartCh.publish({
+        testName,
+        testSuiteAbsolutePath,
+        testSourceLine,
+        browserName
+      })
+
+      let existAfterEachHook = false
+
+      // We try to find an existing afterEach hook with _ddHook to avoid adding a new one
+      for (const hook of test.parent._hooks) {
+        if (hook.type === 'afterEach' && hook._ddHook) {
+          existAfterEachHook = true
+          break
+        }
+      }
+
+      // In cases where there is no afterEach hook with _ddHook, we need to add one
+      if (!existAfterEachHook) {
+        test.parent._hooks.push({
+          type: 'afterEach',
+          fn: async function ({ page }) {
+            try {
+              if (page) {
+                const isRumActive = await page.evaluate(() => {
+                  if (window.DD_RUM && window.DD_RUM.stopSession) {
+                    window.DD_RUM.stopSession()
+                    return true
+                  } else {
+                    return false
+                  }
+                })
+
+                if (isRumActive) {
+                  const url = page.url()
+                  if (url) {
+                    const domain = new URL(url).hostname
+                    await page.context().addCookies([{
+                      name: 'datadog-ci-visibility-test-execution-id',
+                      value: '',
+                      domain,
+                      expires: 0,
+                      path: '/'
+                    }])
+                  }
+                }
+              }
+            } catch (e) {
+              // ignore errors
+            }
+          },
+          title: 'afterEach hook',
+          _ddHook: true
+        })
+      }
+
+      res = _runTest.apply(this, arguments)
+
+      testInfo = this._currentTest
+    })
+    await res
+
+    const { status, error, annotations, retry, testId } = testInfo
+
+    // testInfo.errors could be better than "error",
+    // which will only include timeout error (even though the test failed because of a different error)
+
+    let annotationTags
+    if (annotations.length) {
+      annotationTags = parseAnnotations(annotations)
+    }
+
+    let onDone
+
+    const flushPromise = new Promise(resolve => {
+      onDone = resolve
+    })
+
+    // Wait for ddProperties to be received and processed
+    // Create a promise that will be resolved when the properties are received
+    const ddPropertiesPromise = new Promise(resolve => {
+      const messageHandler = ({ type, testId, properties }) => {
+        if (type === 'ddProperties' && testId === test.id) {
+          // Apply the properties to the test object
+          if (properties) {
+            Object.assign(test, properties)
+          }
+          process.removeListener('message', messageHandler)
+          resolve()
+        }
+      }
+
+      // Add the listener
+      process.on('message', messageHandler)
+    })
+
+    // Wait for the properties to be received
+    await ddPropertiesPromise
+
+    testAsyncResource.runInAsyncScope(() => {
+      testFinishCh.publish({
+        testStatus: STATUS_TO_TEST_STATUS[status],
+        steps: steps.filter(step => step.testId === testId),
+        error,
+        extraTags: annotationTags,
+        isNew: test._ddIsNew,
+        isRetry: retry > 0,
+        isEfdRetry: test._ddIsEfdRetry,
+        isAttemptToFix: test._ddIsAttemptToFix,
+        isDisabled: test._ddIsDisabled,
+        isQuarantined: test._ddIsQuarantined,
+        isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
+        hasFailedAllRetries: test._ddHasFailedAllRetries,
+        hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
+        onDone
+      })
+    })
+
+    await flushPromise
+
+    return res
+  })
+
+  // We reproduce what happens in `Dispatcher#_onStepBegin` and `Dispatcher#_onStepEnd`,
+  // since `startTime` and `duration` are not available directly in the worker process
+  shimmer.wrap(workerPackage.WorkerMain.prototype, 'dispatchEvent', dispatchEvent => function (event, payload) {
+    if (event === 'stepBegin') {
+      stepInfoByStepId[payload.stepId] = {
+        startTime: payload.wallTime,
+        title: payload.title,
+        testId: payload.testId
+      }
+    } else if (event === 'stepEnd') {
+      const stepInfo = stepInfoByStepId[payload.stepId]
+      delete stepInfoByStepId[payload.stepId]
+      steps.push({
+        testId: stepInfo.testId,
+        startTime: new Date(stepInfo.startTime),
+        title: stepInfo.title,
+        duration: payload.wallTime - stepInfo.startTime,
+        error: payload.error
+      })
+    }
+    return dispatchEvent.apply(this, arguments)
+  })
+
+  return workerPackage
+})

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

@@ -19,7 +19,7 @@ function createWrapRouterMethod (name) {
   function wrapLayerHandle (layer, original) {
     original._name = original._name || layer.name
 
-    const handle = shimmer.wrapFunction(original, original => function () {
+    return shimmer.wrapFunction(original, original => function () {
       if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
 
       const matchers = layerMatchers.get(layer)
@@ -59,12 +59,6 @@ function createWrapRouterMethod (name) {
         exitChannel.publish({ req })
       }
     })
-
-    // This is a workaround for the `loopback` library so that it can find the correct express layer
-    // that contains the real handle function
-    handle._datadog_orig = original
-
-    return handle
   }
 
   function wrapStack (stack, offset, matchers) {