dd-trace 5.73.0 → 5.75.0

package/LICENSE-3rdparty.csv

@@ -14,6 +14,7 @@ require,@opentelemetry/resources,Apache license 2.0,Copyright OpenTelemetry Auth
 require,@isaacs/ttlcache,ISC,Copyright (c) 2022-2023 - Isaac Z. Schlueter and Contributors
 require,crypto-randomuuid,MIT,Copyright 2021 Node.js Foundation and contributors
 require,dc-polyfill,MIT,Copyright 2023 Datadog Inc.
+require,escape-string-regexp,MIT,Copyright Sindre Sorhus
 require,ignore,MIT,Copyright 2013 Kael Zhang and contributors
 require,import-in-the-middle,Apache license 2.0,Copyright 2021 Datadog Inc.
 require,istanbul-lib-coverage,BSD-3-Clause,Copyright 2012-2015 Yahoo! Inc.
@@ -50,6 +51,7 @@ dev,@stylistic/eslint-plugin,MIT,Copyright OpenJS Foundation and other contribut
 dev,axios,MIT,Copyright 2014-present Matt Zabriskie
 dev,benchmark,MIT,Copyright 2010-2016 Mathias Bynens Robert Kieffer John-David Dalton
 dev,body-parser,MIT,Copyright 2014 Jonathan Ong 2014-2015 Douglas Christopher Wilson
+dev,bun,MIT,Copyright contributors
 dev,chai,MIT,Copyright 2017 Chai.js Assertion Library
 dev,eslint,MIT,Copyright JS Foundation and other contributors https://js.foundation
 dev,eslint-plugin-cypress,MIT,Copyright (c) 2019 Cypress.io

package/index.d.ts

@@ -134,6 +134,11 @@ interface Tracer extends opentracing.Tracer {
 
   dogstatsd: tracer.DogStatsD;
 
+  /**
+   * Data Streams manual checkpointer API.
+   */
+  dataStreamsCheckpointer: tracer.DataStreamsCheckpointer;
+
   /**
    * LLM Observability SDK
    */
@@ -176,6 +181,7 @@ interface Tracer extends opentracing.Tracer {
 /** @hidden */
 interface Plugins {
   "aerospike": tracer.plugins.aerospike;
+  "ai": tracer.plugins.ai;
   "amqp10": tracer.plugins.amqp10;
   "amqplib": tracer.plugins.amqplib;
   "anthropic": tracer.plugins.anthropic;
@@ -1026,6 +1032,29 @@ declare namespace tracer {
     flush(): void
   }
 
+  /**
+   * Manual Data Streams Monitoring checkpointer API.
+   */
+  export interface DataStreamsCheckpointer {
+    /**
+     * Sets a produce checkpoint and injects the DSM context into the provided carrier.
+     * @param type The streaming technology (e.g., kafka, kinesis, sns).
+     * @param target The target of data (topic, exchange, stream name).
+     * @param carrier The carrier object to inject DSM context into.
+     */
+    setProduceCheckpoint (type: string, target: string, carrier: any): void;
+
+    /**
+     * Sets a consume checkpoint and extracts DSM context from the provided carrier.
+     * @param type The streaming technology (e.g., kafka, kinesis, sns).
+     * @param source The source of data (topic, exchange, stream name).
+     * @param carrier The carrier object to extract DSM context from.
+     * @param manualCheckpoint Whether this checkpoint was manually set. Defaults to true.
+     * @returns The DSM context associated with the current pathway.
+     */
+    setConsumeCheckpoint (type: string, source: string, carrier: any, manualCheckpoint?: boolean): any;
+  }
+
   export interface EventTrackingV2 {
     /**
      * Links a successful login event to the current trace. Will link the passed user to the current trace with Appsec.setUser() internally.
@@ -1614,6 +1643,12 @@ declare namespace tracer {
      */
     interface aerospike extends Instrumentation {}
 
+    /**
+     * This plugin automatically instruments the
+     * [Vercel AI SDK](https://ai-sdk.dev/docs/introduction) module.
+     */
+    interface ai extends Instrumentation {}
+
     /**
      * This plugin automatically instruments the
      * [amqp10](https://github.com/noodlefrenzy/node-amqp10) module.
@@ -1670,12 +1705,6 @@ declare namespace tracer {
      * [aws-sdk](https://github.com/aws/aws-sdk-js) module.
      */
     interface aws_sdk extends Instrumentation {
-      /**
-       * Whether to add a suffix to the service name so that each AWS service has its own service name.
-       * @default true
-       */
-      splitByAwsService?: boolean;
-
       /**
        * Whether to inject all messages during batch AWS SQS, Kinesis, and SNS send operations. Normal
        * behavior is to inject the first message in batch send operations.
@@ -2793,7 +2822,10 @@ declare namespace tracer {
     redactionValuePattern?: string,
 
     /**
-     * Allows to enable security controls.
+     * Allows to enable security controls. This option is not supported when
+     * using ESM.
+     * @deprecated Please use the DD_IAST_SECURITY_CONTROLS_CONFIGURATION
+     * environment variable instead.
      */
     securityControlsConfiguration?: string,
 

package/loader-hook.mjs

@@ -1 +1,52 @@
-export * from 'import-in-the-middle/hook.mjs'
+import regexpEscape from 'escape-string-regexp'
+import * as iitm from 'import-in-the-middle/hook.mjs'
+import hooks from './packages/datadog-instrumentations/src/helpers/hooks.js'
+import configHelper from './packages/dd-trace/src/config-helper.js'
+
+// For some reason `getEnvironmentVariable` is not otherwise available to ESM.
+const env = configHelper.getEnvironmentVariable
+
+function initialize (data = {}) {
+  data.include ??= []
+  data.exclude ??= []
+
+  addInstrumentations(data)
+  addSecurityControls(data)
+  addExclusions(data)
+
+  return iitm.initialize(data)
+}
+
+function addInstrumentations (data) {
+  const instrumentations = Object.keys(hooks)
+
+  for (const moduleName of instrumentations) {
+    data.include.push(new RegExp(`node_modules/${moduleName}/(?!node_modules).+`), moduleName)
+  }
+}
+
+function addSecurityControls (data) {
+  const securityControls = (env('DD_IAST_SECURITY_CONTROLS_CONFIGURATION') || '')
+    .split(';')
+    .map(sc => sc.trim().split(':')[2])
+    .filter(Boolean)
+    .map(sc => sc.trim())
+
+  for (const subpath of securityControls) {
+    data.include.push(new RegExp(regexpEscape(subpath)))
+  }
+}
+
+function addExclusions (data) {
+  data.exclude.push(
+    /middle/,
+    /langsmith/,
+    /openai\/_shims/,
+    /openai\/resources\/chat\/completions\/messages/,
+    /openai\/agents-core\/dist\/shims/,
+    /@anthropic-ai\/sdk\/_shims/
+  )
+}
+
+export { initialize }
+export { load, getFormat, resolve, getSource } from 'import-in-the-middle/hook.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.73.0",
+  "version": "5.75.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -32,6 +32,8 @@
     "test:trace:core:ci": "npm run test:trace:core -- --coverage --nyc-arg=--include=\"packages/dd-trace/src/**/*.js\"",
     "test:trace:guardrails": "mocha -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/dd-trace/test/guardrails/**/*.spec.js\"",
     "test:trace:guardrails:ci": "nyc --no-clean --include \"packages/dd-trace/src/guardrails/**/*.js\" -- npm run test:trace:guardrails",
+    "test:esbuild": "mocha -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/datadog-esbuild/test/**/*.spec.js\"",
+    "test:esbuild:ci": "nyc --no-clean --include \"packages/datadog-esbuild/test/**/*.js\" -- npm run test:esbuild",
     "test:instrumentations": "mocha -r 'packages/dd-trace/test/setup/mocha.js' \"packages/datadog-instrumentations/test/@($(echo $PLUGINS)).spec.js\"",
     "test:instrumentations:ci": "yarn services && nyc --no-clean --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS)).js\" --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS))/**/*.js\" -- npm run test:instrumentations",
     "test:instrumentations:misc": "mocha -r 'packages/dd-trace/test/setup/mocha.js' 'packages/datadog-instrumentations/test/*/**/*.spec.js'",
@@ -134,6 +136,7 @@
     "@opentelemetry/resources": ">=1.0.0 <1.10.0",
     "crypto-randomuuid": "^1.0.0",
     "dc-polyfill": "^0.1.10",
+    "escape-string-regexp": "^5.0.0",
     "ignore": "^7.0.5",
     "import-in-the-middle": "^1.14.2",
     "istanbul-lib-coverage": "^3.2.2",
@@ -156,25 +159,13 @@
     "tlhunter-sorted-set": "^0.1.0",
     "ttl-set": "^1.0.0"
   },
-  "peerDependencies": {
-    "@openfeature/core": "^1.9.0",
-    "@openfeature/server-sdk": "~1.19.0"
-  },
-  "peerDependenciesMeta": {
-    "@openfeature/core": {
-      "optional": true
-    },
-    "@openfeature/server-sdk": {
-      "optional": true
-    }
-  },
   "devDependencies": {
     "@babel/helpers": "^7.27.6",
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.29.0",
     "@msgpack/msgpack": "^3.1.2",
-    "@openfeature/core": "^1.8.1",
-    "@openfeature/server-sdk": "~1.19.0",
+    "@openfeature/core": "^1.9.0",
+    "@openfeature/server-sdk": "^1.20.0",
     "@stylistic/eslint-plugin": "^5.0.0",
     "@types/chai": "^4.3.16",
     "@types/mocha": "^10.0.10",
@@ -184,6 +175,7 @@
     "axios": "^1.12.2",
     "benchmark": "^2.1.4",
     "body-parser": "^2.2.0",
+    "bun": "1.3.1",
     "chai": "^4.5.0",
     "eslint": "^9.29.0",
     "eslint-plugin-cypress": "^5.1.0",
@@ -211,7 +203,7 @@
     "tap": "^16.3.10",
     "tiktoken": "^1.0.21",
     "typescript": "^5.9.2",
-    "workerpool": "^9.2.0",
+    "workerpool": "^10.0.0",
     "yaml": "^2.8.0",
     "yarn-deduplicate": "^6.0.2"
   }

package/packages/datadog-core/src/utils/src/set.js

@@ -5,7 +5,11 @@ module.exports = function set (object, path, value) {
   while (true) {
     const nextIndex = path.indexOf('.', index + 1)
     if (nextIndex === -1) {
-      object[path.slice(index + 1)] = value
+      if (index === -1) {
+        object[path] = value
+      } else {
+        object[path.slice(index + 1)] = value
+      }
       return
     }
     object = object[path.slice(index + 1, nextIndex)] ??= {}

package/packages/datadog-esbuild/index.js

@@ -8,6 +8,12 @@ const extractPackageAndModulePath = require(
   '../datadog-instrumentations/src/helpers/extract-package-and-module-path.js'
 )
 
+const { pathToFileURL, fileURLToPath } = require('url')
+const { processModule, isESMFile } = require('./src/utils.js')
+
+const ESM_INTERCEPTED_SUFFIX = '._dd_esbuild_intercepted'
+const INTERNAL_ESM_INTERCEPTED_PREFIX = '/_dd_esm_internal_/'
+
 let rewriter
 
 for (const hook of Object.values(hooks)) {
@@ -30,7 +36,6 @@ for (const instrumentation of Object.values(instrumentations)) {
   }
 }
 
-const INSTRUMENTED = Object.keys(instrumentations)
 const RAW_BUILTINS = require('module').builtinModules
 const CHANNEL = 'dd-trace:bundler:load'
 const path = require('path')
@@ -47,14 +52,6 @@ for (const builtin of RAW_BUILTINS) {
 const DEBUG = !!process.env.DD_TRACE_DEBUG
 const DD_IAST_ENABLED = process.env.DD_IAST_ENABLED?.toLowerCase() === 'true' || process.env.DD_IAST_ENABLED === '1'
 
-// We don't want to handle any built-in packages
-// Those packages will still be handled via RITM
-// Attempting to instrument them would fail as they have no package.json file
-for (const pkg of INSTRUMENTED) {
-  if (builtins.has(pkg) || pkg.startsWith('node:')) continue
-  modulesOfInterest.add(pkg)
-}
-
 module.exports.name = 'datadog-esbuild'
 
 function isESMBuild (build) {
@@ -117,13 +114,15 @@ ${build.initialOptions.banner.js}`
   }
 
   try {
+    // eslint-disable-next-line n/no-unpublished-require
     require.resolve('@openfeature/core')
   } catch (error) {
     build.initialOptions.external ??= []
     build.initialOptions.external.push('@openfeature/core')
   }
 
-  if (isESMBuild(build)) {
+  const esmBuild = isESMBuild(build)
+  if (esmBuild) {
     if (!build.initialOptions.banner.js.includes('import { createRequire as $dd_createRequire } from \'module\'')) {
       build.initialOptions.banner.js = `import { createRequire as $dd_createRequire } from 'module';
 import { fileURLToPath as $dd_fileURLToPath } from 'url';
@@ -157,6 +156,9 @@ ${build.initialOptions.banner.js}`
     console.warn('Warning: No git metadata available - skipping injection')
   }
 
+  // first time is intercepted, proxy should be created, next time the original should be loaded
+  const interceptedESMModules = new Set()
+
   build.onResolve({ filter: /.*/ }, args => {
     if (externalModules.has(args.path)) {
       // Internal Node.js packages will still be instrumented via require()
@@ -175,7 +177,7 @@ ${build.initialOptions.banner.js}`
 
     let fullPathToModule
     try {
-      fullPathToModule = dotFriendlyResolve(args.path, args.resolveDir)
+      fullPathToModule = dotFriendlyResolve(args.path, args.resolveDir, args.kind === 'import-statement')
     } catch (err) {
       if (DEBUG) {
         console.warn(`Warning: Unable to find "${args.path}".` +
@@ -205,8 +207,25 @@ ${build.initialOptions.banner.js}`
     if (args.namespace === 'file' && (
       modulesOfInterest.has(args.path) || modulesOfInterest.has(`${extracted.pkg}/${extracted.path}`))
     ) {
+      // Internal module like http/fs is imported and the build output is ESM
+      if (internal && args.kind === 'import-statement' && esmBuild && !interceptedESMModules.has(fullPathToModule)) {
+        fullPathToModule = `${INTERNAL_ESM_INTERCEPTED_PREFIX}${fullPathToModule}${ESM_INTERCEPTED_SUFFIX}`
+
+        return {
+          path: fullPathToModule,
+          pluginData: {
+            pkg: extracted?.pkg,
+            path: extracted?.path,
+            full: fullPathToModule,
+            raw: args.path,
+            pkgOfInterest: true,
+            kind: args.kind,
+            internal,
+            isESM: true
+          }
+        }
+      }
       // The file namespace is used when requiring files from disk in userland
-
       let pathToPackageJson
       try {
         // we can't use require.resolve('pkg/package.json') as ESM modules don't make the file available
@@ -228,6 +247,11 @@ ${build.initialOptions.banner.js}`
 
       const packageJson = JSON.parse(fs.readFileSync(pathToPackageJson).toString())
 
+      const isESM = isESMFile(fullPathToModule, pathToPackageJson, packageJson)
+      if (isESM && !interceptedESMModules.has(fullPathToModule)) {
+        fullPathToModule += ESM_INTERCEPTED_SUFFIX
+      }
+
       if (DEBUG) console.log(`RESOLVE: ${args.path}@${packageJson.version}`)
 
       // https://esbuild.github.io/plugins/#on-resolve-arguments
@@ -240,13 +264,15 @@ ${build.initialOptions.banner.js}`
           full: fullPathToModule,
           raw: args.path,
           pkgOfInterest: true,
-          internal
+          kind: args.kind,
+          internal,
+          isESM
         }
       }
     }
   })
 
-  build.onLoad({ filter: /.*/ }, args => {
+  build.onLoad({ filter: /.*/ }, async args => {
     if (args.pluginData?.pkgOfInterest) {
       const data = args.pluginData
 
@@ -257,26 +283,63 @@ ${build.initialOptions.banner.js}`
         : data.pkg
 
       // Read the content of the module file of interest
-      const fileCode = fs.readFileSync(args.path, 'utf8')
+      let contents
+
+      if (data.isESM) {
+        if (args.path.endsWith(ESM_INTERCEPTED_SUFFIX)) {
+          args.path = args.path.slice(0, -1 * ESM_INTERCEPTED_SUFFIX.length)
+
+          if (data.internal) {
+            args.path = args.path.slice(INTERNAL_ESM_INTERCEPTED_PREFIX.length)
+          }
+
+          interceptedESMModules.add(args.path)
+
+          const setters = await processModule({
+            path: args.path,
+            internal: data.internal,
+            context: { format: 'module' }
+          })
+
+          const iitmPath = require.resolve('import-in-the-middle/lib/register.js')
+          const toRegister = data.internal ? args.path : pathToFileURL(args.path)
+          // Mimic a Module object (https://tc39.es/ecma262/#sec-module-namespace-objects).
+          contents = `
+import { register } from ${JSON.stringify(iitmPath)};
+import * as namespace from ${JSON.stringify(args.path)};
+const _ = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
+const set = {};
+const get = {};
+
+${Array.from(setters.values()).join(';\n')};
+
+register(${JSON.stringify(toRegister)}, _, set, get, ${JSON.stringify(data.raw)});
+`
+        } else {
+          contents = fs.readFileSync(args.path, 'utf8')
+        }
+      } else {
+        const fileCode = fs.readFileSync(args.path, 'utf8')
+        contents = `
+        (function() {
+          ${fileCode}
+        })(...arguments);
+        {
+          const dc = require('dc-polyfill');
+          const ch = dc.channel('${CHANNEL}');
+          const mod = module.exports
+          const payload = {
+            module: mod,
+            version: '${data.version}',
+            package: '${data.pkg}',
+            path: '${pkgPath}'
+          };
+          ch.publish(payload);
+          module.exports = payload.module;
+      }
+      `
+      }
 
-      const contents = `
-      (function() {
-        ${fileCode}
-      })(...arguments);
-      {
-        const dc = require('dc-polyfill');
-        const ch = dc.channel('${CHANNEL}');
-        const mod = module.exports
-        const payload = {
-          module: mod,
-          version: '${data.version}',
-          package: '${data.pkg}',
-          path: '${pkgPath}'
-        };
-        ch.publish(payload);
-        module.exports = payload.module;
-    }
-    `
       // https://esbuild.github.io/plugins/#on-load-results
       return {
         contents,
@@ -284,7 +347,6 @@ ${build.initialOptions.banner.js}`
         resolveDir: path.dirname(args.path)
       }
     }
-
     if (DD_IAST_ENABLED && args.pluginData?.applicationFile) {
       const ext = path.extname(args.path).toLowerCase()
       const isJs = /^\.(js|mjs|cjs)$/.test(ext)
@@ -303,12 +365,19 @@ ${build.initialOptions.banner.js}`
 }
 
 // @see https://github.com/nodejs/node/issues/47000
-function dotFriendlyResolve (path, directory) {
+function dotFriendlyResolve (path, directory, usesImportStatement) {
   if (path === '.') {
     path = './'
   } else if (path === '..') {
     path = '../'
   }
+  let conditions
+  if (usesImportStatement) {
+    conditions = new Set(['import', 'node'])
+  }
 
-  return require.resolve(path, { paths: [directory] })
+  if (path.startsWith('file://')) {
+    path = fileURLToPath(path)
+  }
+  return require.resolve(path, { paths: [directory], conditions })
 }

package/packages/datadog-esbuild/src/utils.js

@@ -0,0 +1,198 @@
+'use strict'
+
+// The content of this file is copied from the `import-in-the-middle` package with minor modifications (https://www.npmjs.com/package/import-in-the-middle)
+const { pathToFileURL, fileURLToPath } = require('node:url')
+const fs = require('node:fs')
+const path = require('node:path')
+const { NODE_MAJOR, NODE_MINOR } = require('../../../version.js')
+
+const getExportsImporting = (url) => import(url).then(Object.keys)
+const getExports = NODE_MAJOR >= 20 || (NODE_MAJOR === 18 && NODE_MINOR >= 19)
+  ? require('import-in-the-middle/lib/get-exports.js')
+  : getExportsImporting
+
+function isStarExportLine (line) {
+  return /^\* from /.test(line)
+}
+
+function isBareSpecifier (specifier) {
+  // Relative and absolute paths are not bare specifiers.
+  if (
+    specifier.startsWith('.') ||
+    specifier.startsWith('/')) {
+    return false
+  }
+
+  // Valid URLs are not bare specifiers. (file:, http:, node:, etc.)
+
+  if (URL.hasOwnProperty('canParse')) {
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins
+    return !URL.canParse(specifier)
+  }
+
+  try {
+    // eslint-disable-next-line no-new
+    new URL(specifier)
+    return false
+  } catch {
+    return true
+  }
+}
+
+function resolve (specifier, context) {
+  // This comes from an import, that is why import makes preference
+  const conditions = ['import']
+
+  if (specifier.startsWith('file://')) {
+    specifier = fileURLToPath(specifier)
+  }
+
+  const resolved = require.resolve(specifier, { conditions, paths: [fileURLToPath(context.parentURL)] })
+
+  return {
+    url: pathToFileURL(resolved),
+    format: isESMFile(resolved) ? 'module' : 'commonjs'
+  }
+}
+
+function getSource (url, { format }) {
+  return {
+    source: fs.readFileSync(fileURLToPath(url), 'utf8'),
+    format
+  }
+}
+
+/**
+ * Generates the pieces of code for the proxy module before the path
+ *
+ * @param {Object} moduleData { path, internal, context, excludeDefault }
+ * @returns {Promise<Map>}
+ */
+async function processModule ({ path, internal, context, excludeDefault }) {
+  let exportNames, srcUrl
+  if (internal) {
+    // we can not read and parse of internal modules
+    exportNames = await getExportsImporting(path)
+  } else {
+    srcUrl = pathToFileURL(path)
+    exportNames = await getExports(srcUrl, context, getSource)
+  }
+
+  const starExports = new Set()
+  const setters = new Map()
+
+  const addSetter = (name, setter, isStarExport = false) => {
+    if (setters.has(name)) {
+      if (isStarExport) {
+        // If there's already a matching star export, delete it
+        if (starExports.has(name)) {
+          setters.delete(name)
+        }
+        // and return so this is excluded
+        return
+      }
+
+      // if we already have this export but it is from a * export, overwrite it
+      if (starExports.has(name)) {
+        starExports.delete(name)
+        setters.set(name, setter)
+      }
+    } else {
+      // Store export * exports so we know they can be overridden by explicit
+      // named exports
+      if (isStarExport) {
+        starExports.add(name)
+      }
+
+      setters.set(name, setter)
+    }
+  }
+
+  for (const n of exportNames) {
+    if (n === 'default' && excludeDefault) continue
+
+    if (isStarExportLine(n) === true) {
+      // export * from 'wherever'
+      const [, modFile] = n.split('* from ')
+
+      // Relative paths need to be resolved relative to the parent module
+      const newSpecifier = isBareSpecifier(modFile) ? modFile : new URL(modFile, srcUrl).href
+      // We need to call `parentResolve` to resolve bare specifiers to a full
+      // URL. We also need to call `parentResolve` for all sub-modules to get
+      // the `format`. We can't rely on the parents `format` to know if this
+      // sub-module is ESM or CJS!
+
+      const result = resolve(newSpecifier, { parentURL: srcUrl })
+
+      // eslint-disable-next-line no-await-in-loop
+      const subSetters = await processModule({
+        path: fileURLToPath(result.url),
+        context: { ...context, format: result.format },
+        excludeDefault: true
+      })
+
+      for (const [name, setter] of subSetters.entries()) {
+        addSetter(name, setter, true)
+      }
+    } else {
+      const variableName = `$${n.replaceAll(/[^a-zA-Z0-9_$]/g, '_')}`
+      const objectKey = JSON.stringify(n)
+      const reExportedName = n === 'default' ? n : objectKey
+
+      addSetter(n, `
+      let ${variableName}
+      try {
+        ${variableName} = _[${objectKey}] = namespace[${objectKey}]
+      } catch (err) {
+        if (!(err instanceof ReferenceError)) throw err
+      }
+      export { ${variableName} as ${reExportedName} }
+      set[${objectKey}] = (v) => {
+        ${variableName} = v
+        return true
+      }
+      get[${objectKey}] = () => ${variableName}
+      `)
+    }
+  }
+
+  return setters
+}
+
+/**
+ * Determines if a file is a ESM module or CommonJS
+ *
+ * @param {string} fullPathToModule File to analize
+ * @param {string} [modulePackageJsonPath] Path of the package.json
+ * @param {Object} [packageJson] The content of the module package.json
+ * @returns {boolean}
+ */
+function isESMFile (fullPathToModule, modulePackageJsonPath, packageJson = {}) {
+  if (fullPathToModule.endsWith('.mjs')) return true
+  if (fullPathToModule.endsWith('.cjs')) return false
+
+  const pathParts = fullPathToModule.split(path.sep)
+  do {
+    pathParts.pop()
+
+    const packageJsonPath = [...pathParts, 'package.json'].join(path.sep)
+    if (packageJsonPath === modulePackageJsonPath) {
+      return packageJson.type === 'module'
+    }
+
+    try {
+      const packageJsonContent = fs.readFileSync(packageJsonPath).toString()
+      const packageJson = JSON.parse(packageJsonContent)
+      return packageJson.type === 'module'
+    } catch {
+      // file does not exit, continue
+    }
+  } while (pathParts.length > 0)
+
+  return packageJson.type === 'module'
+}
+
+module.exports = {
+  processModule,
+  isESMFile
+}

package/packages/datadog-instrumentations/src/cookie-parser.js

@@ -25,8 +25,6 @@ addHook({
   name: 'cookie-parser',
   versions: ['>=1.0.0']
 }, cookieParser => {
-  // This prevents the non default export from entering the wrapping process
-  if (cookieParser.default) return cookieParser
   return shimmer.wrapFunction(cookieParser, cookieParser => function () {
     const cookieMiddleware = cookieParser.apply(this, arguments)