@depup/dd-trace 5.90.0-depup.0

package/index.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./packages/dd-trace')

package/init.js

@@ -0,0 +1,7 @@
+'use strict'
+
+var guard = require('./packages/dd-trace/src/guardrails')
+
+module.exports = guard(function () {
+  return require('.').init()
+})

package/initialize.mjs

@@ -0,0 +1,85 @@
+/**
+ * This file serves one of two purposes, depending on how it's used.
+ *
+ * If used with --import, it will import init.js and register the loader hook.
+ * If used with --loader, it will act as the loader hook.
+ *
+ * The result is that no matter how this file is used, so long as it's with
+ * one of the two flags, the tracer will always be initialized, and the loader
+ * hook will always be active for ESM support.
+ */
+
+/* eslint n/no-unsupported-features/node-builtins: ['error', { ignores: ['module.register'] }] */
+
+import { Buffer } from 'buffer'
+import * as Module from 'module'
+import { types } from 'util'
+import { isMainThread } from 'worker_threads'
+
+// This file must support Node.js 12.0.0 syntax
+
+import {
+  iitmExclusions,
+  load as hookLoad,
+  resolve as hookResolve,
+} from './loader-hook.mjs'
+
+let hasInsertedInit = false
+const initJsUrl = new URL('init.js', import.meta.url).href
+// `--loader` only reliably influences ESM entrypoints; for CJS apps use `--import`/`--require`.
+
+/**
+ * @param {{ source?: string|Buffer|Uint8Array, format?: string }} result
+ * @param {unknown} _url_
+ * @param {{ format?: string, isMain?: boolean }} context
+ * @returns {{ source?: string|Buffer|Uint8Array, format?: string }}
+ */
+function insertInit (result, _url_, context) {
+  if (hasInsertedInit) return result
+  // If Node provides `isMain`, only inject into the entrypoint module.
+  if (context && context.isMain === false) return result
+
+  let { source } = result
+  if (typeof source !== 'string') {
+    // Fast decode: handle bytes sources without extra copies when possible.
+    if (Buffer.isBuffer(source)) {
+      source = source.toString('utf8')
+    } else if (types.isUint8Array(source)) {
+      // Create a Buffer view over the same ArrayBuffer segment (no copy).
+      source = Buffer.from(source.buffer, source.byteOffset, source.byteLength).toString('utf8')
+    } else {
+      return result
+    }
+  }
+
+  const format = result.format || (context && context.format)
+  if (format !== 'module') return result
+
+  hasInsertedInit = true
+
+  result.source = `import ${JSON.stringify(initJsUrl)};\n${source}`
+
+  return result
+}
+
+const [NODE_MAJOR, NODE_MINOR] = process.versions.node.split('.').map(Number)
+
+const brokenLoaders = NODE_MAJOR === 18 && NODE_MINOR === 0
+
+export async function load (url, context, nextLoad) {
+  const iitmExclusionsMatch = iitmExclusions.some((exclusion) => exclusion.test(url))
+  const loadHook = (brokenLoaders || iitmExclusionsMatch) ? nextLoad : hookLoad
+  return insertInit(await loadHook(url, context, nextLoad), url, context)
+}
+
+export const resolve = brokenLoaders ? undefined : hookResolve
+
+if (isMainThread) {
+  const require = Module.createRequire(import.meta.url)
+  require('./init.js')
+  if (Module.register) {
+    Module.register('./loader-hook.mjs', import.meta.url, {
+      data: { exclude: iitmExclusions },
+    })
+  }
+}

package/loader-hook.mjs

@@ -0,0 +1,77 @@
+import { initialize as origInitialize, load as origLoad, resolve } from 'import-in-the-middle/hook.mjs'
+import regexpEscapeModule from './vendor/dist/escape-string-regexp/index.js'
+import hooks from './packages/datadog-instrumentations/src/helpers/hooks.js'
+import configHelper from './packages/dd-trace/src/config/helper.js'
+import * as rewriterLoader from './packages/datadog-instrumentations/src/helpers/rewriter/loader.mjs'
+import { isRelativeRequire } from './packages/datadog-instrumentations/src/helpers/shared-utils.js'
+
+// This file must support Node.js 12.0.0 syntax
+
+const regexpEscape = regexpEscapeModule.default
+
+// For some reason `getEnvironmentVariable` is not otherwise available to ESM.
+const env = configHelper.getEnvironmentVariable
+
+function initialize (data = {}) {
+  if (data.include == null) data.include = []
+  if (data.exclude == null) data.exclude = []
+
+  addInstrumentations(data)
+  addSecurityControls(data)
+  addExclusions(data)
+
+  return origInitialize(data)
+}
+
+function load (url, context, nextLoad) {
+  return rewriterLoader.load(url, context, (url, context) => origLoad(url, context, nextLoad))
+}
+
+function addInstrumentations (data) {
+  const instrumentations = Object.keys(hooks)
+
+  for (const moduleName of instrumentations) {
+    // Skip instrumentation hooks with relative module names
+    // since there is no current business need of instrumenting imports outside of the node_modules folder
+    if (!isRelativeRequire(moduleName)) {
+      data.include.push(new RegExp(`node_modules/${moduleName}/(?!node_modules).+`), moduleName)
+    }
+  }
+}
+
+function addSecurityControls (data) {
+  const raw = env('DD_IAST_SECURITY_CONTROLS_CONFIGURATION')
+  if (!raw) return
+  // Parse `;`-separated entries and take the 3rd `:`-separated segment.
+  // Expected form (per entry): `<...>:<...>:<subpath>:<...>`
+  const entries = raw.split(';')
+  for (const entry of entries) {
+    if (entry) {
+      const first = entry.indexOf(':')
+      if (first === -1) continue
+      const second = entry.indexOf(':', first + 1)
+      if (second === -1) continue
+      const third = entry.indexOf(':', second + 1)
+
+      const subpath = entry.slice(second + 1, third === -1 ? undefined : third).trim()
+      if (subpath) {
+        data.include.push(new RegExp(regexpEscape(subpath)))
+      }
+    }
+  }
+}
+
+function addExclusions (data) {
+  data.exclude.push(...iitmExclusions)
+}
+
+export const iitmExclusions = [
+  /middle/,
+  /langsmith/,
+  /openai\/_shims/,
+  /openai\/resources\/chat\/completions\/messages/,
+  /openai\/agents-core\/dist\/shims/,
+  /@anthropic-ai\/sdk\/_shims/,
+]
+
+export { initialize, load, resolve }

package/package.json

@@ -0,0 +1,215 @@
+{
+  "name": "@depup/dd-trace",
+  "version": "5.90.0-depup.0",
+  "description": "[DepUp] Datadog APM tracing client for JavaScript",
+  "main": "index.js",
+  "typings": "index.d.ts",
+  "scripts": {
+    "env": "bash ./plugin-env",
+    "bench": "node benchmark/index.js",
+    "bench:e2e:test-optimization": "node benchmark/e2e-test-optimization/benchmark-run.js",
+    "dependencies:dedupe": "yarn-deduplicate yarn.lock",
+    "type:check": "tsc --noEmit -p tsconfig.dev.json",
+    "type:doc:build": "cd docs && yarn && yarn build",
+    "type:doc:test": "cd docs && yarn && yarn test",
+    "lint": "node scripts/check_licenses.js && node scripts/check-no-coverage-artifacts.js && eslint . --concurrency=auto --max-warnings 0",
+    "lint:fix": "node scripts/check_licenses.js && node scripts/check-no-coverage-artifacts.js && eslint . --concurrency=auto --max-warnings 0 --fix",
+    "lint:inspect": "npx @eslint/config-inspector@latest",
+    "lint:codeowners": "codeowners-audit",
+    "lint:codeowners:ci": "codeowners-audit --glob='**/*.spec.js'",
+    "release:proposal": "node scripts/release/proposal",
+    "services": "node ./scripts/install_plugin_modules && node packages/dd-trace/test/setup/services",
+    "test": "echo '\nError: The root \"npm test\" command is intentionally disabled.\n\nInstead, run specific test suites:\n  - npm run test:trace:core\n  - npm run test:appsec\n  - etc.\n\nOr run individual test files:\n  npx mocha path/to/test.spec.js\n\nSee CONTRIBUTING.md (Testing section) for more details.\n' && exit 1",
+    "test:aiguard": "mocha packages/dd-trace/test/aiguard/**/*.spec.js",
+    "test:aiguard:ci": "nyc -- npm run test:aiguard",
+    "test:appsec": "mocha --exclude \"packages/dd-trace/test/appsec/**/*.plugin.spec.js\" \"packages/dd-trace/test/appsec/**/*.spec.js\"",
+    "test:appsec:ci": "nyc -- npm run test:appsec",
+    "test:appsec:plugins": "mocha \"packages/dd-trace/test/appsec/**/*.@(${PLUGINS}).plugin.spec.js\"",
+    "test:appsec:plugins:ci": "yarn services && nyc -- npm run test:appsec:plugins",
+    "test:debugger": "mocha packages/dd-trace/test/debugger/**/*.spec.js",
+    "test:debugger:ci": "nyc -- npm run test:debugger",
+    "test:eslint-rules": "node eslint-rules/*.test.mjs",
+    "test:trace:core": "node scripts/mocha-parallel-files.js --expose-gc --timeout 30000 -- \"packages/dd-trace/test/*.spec.js\" \"packages/dd-trace/test/{agent,ci-visibility,config,crashtracking,datastreams,encode,exporters,msgpack,opentelemetry,opentracing,payload-tagging,plugins,remote_config,service-naming,standalone,telemetry,external-logger}/**/*.spec.js\"",
+    "test:trace:core:ci": "nyc -- npm run test:trace:core",
+    "test:trace:guardrails": "mocha packages/dd-trace/test/guardrails/**/*.spec.js",
+    "test:trace:guardrails:ci": "nyc -- npm run test:trace:guardrails",
+    "test:esbuild": "mocha packages/datadog-esbuild/test/**/*.spec.js",
+    "test:esbuild:ci": "nyc -- npm run test:esbuild",
+    "test:instrumentations": "mocha \"packages/datadog-instrumentations/test/@(${PLUGINS}).spec.js\"",
+    "test:instrumentations:ci": "yarn services && nyc -- npm run test:instrumentations",
+    "test:instrumentations:misc": "mocha packages/datadog-instrumentations/test/*/**/*.spec.js",
+    "test:instrumentations:misc:ci": "nyc -- npm run test:instrumentations:misc",
+    "test:core": "node scripts/mocha-parallel-files.js --expose-gc --timeout 30000 -- packages/datadog-core/test/**/*.spec.js",
+    "test:core:ci": "nyc -- npm run test:core",
+    "test:code-origin": "mocha packages/datadog-code-origin/test/**/*.spec.js",
+    "test:code-origin:ci": "nyc -- npm run test:code-origin",
+    "test:lambda": "mocha packages/dd-trace/test/lambda/**/*.spec.js",
+    "test:lambda:ci": "nyc -- npm run test:lambda",
+    "test:llmobs:sdk": "mocha --exclude \"packages/dd-trace/test/llmobs/plugins/**/*.spec.js\" \"packages/dd-trace/test/llmobs/**/*.spec.js\"",
+    "test:llmobs:sdk:ci": "nyc -- npm run test:llmobs:sdk",
+    "test:llmobs:plugins": "mocha \"packages/dd-trace/test/llmobs/plugins/@(${PLUGINS})/*.spec.js\"",
+    "test:llmobs:plugins:ci": "yarn services && nyc -- npm run test:llmobs:plugins",
+    "test:openfeature": "mocha packages/dd-trace/test/openfeature/**/*.spec.js",
+    "test:openfeature:ci": "nyc -- npm run test:openfeature",
+    "test:plugins": "node --expose-gc ./node_modules/mocha/bin/mocha.js \"packages/datadog-plugin-@(${PLUGINS})/test/**/${SPEC:-*}*.spec.js\"",
+    "test:plugins:ci": "yarn services && nyc -- npm run test:plugins",
+    "test:plugins:ci:flaky": "yarn services && nyc -- npm run test:plugins -- --bail --retries 2",
+    "test:plugins:upstream": "node ./packages/dd-trace/test/plugins/suite.js",
+    "test:profiler": "node scripts/mocha-parallel-files.js --expose-gc --timeout 30000 -- packages/dd-trace/test/profiling/**/*.spec.js",
+    "test:profiler:ci": "nyc -- npm run test:profiler",
+    "test:integration": "mocha --timeout 60000 \"integration-tests/*.spec.js\"",
+    "test:integration:aiguard": "mocha --timeout 60000 \"integration-tests/aiguard/*.spec.js\"",
+    "test:integration:appsec": "mocha --timeout 60000 \"integration-tests/appsec/*.spec.js\"",
+    "test:integration:bun": "mocha --timeout 60000 \"integration-tests/bun/*.spec.js\"",
+    "test:integration:cucumber": "mocha --timeout 60000 \"integration-tests/cucumber/*.spec.js\"",
+    "test:integration:cypress": "mocha --timeout 60000 \"integration-tests/cypress/*.spec.js\"",
+    "test:integration:debugger": "mocha --timeout 60000 \"integration-tests/debugger/*.spec.js\"",
+    "test:integration:esbuild": "mocha --timeout 60000 \"integration-tests/esbuild/*.spec.js\"",
+    "test:integration:openfeature": "mocha --timeout 60000 \"integration-tests/openfeature/*.spec.js\"",
+    "test:integration:jest": "mocha --timeout 60000 \"integration-tests/jest/*.spec.js\"",
+    "test:integration:mocha": "mocha --timeout 60000 \"integration-tests/mocha/*.spec.js\"",
+    "test:integration:playwright": "mocha --timeout 60000 \"integration-tests/playwright/*.spec.js\"",
+    "test:integration:selenium": "mocha --timeout 60000 \"integration-tests/selenium/*.spec.js\"",
+    "test:integration:vitest": "mocha --timeout 60000 \"integration-tests/vitest/*.spec.js\"",
+    "test:integration:testopt": "mocha --timeout 120000 \"integration-tests/ci-visibility/*.spec.js\"",
+    "test:integration:profiler": "mocha --timeout 180000 \"integration-tests/profiler/*.spec.js\"",
+    "test:integration:plugins": "mocha \"packages/datadog-plugin-@(${PLUGINS})/test/integration-test/**/*.spec.js\"",
+    "test:unit:plugins": "mocha \"packages/datadog-instrumentations/test/@(${PLUGINS}).spec.js\" \"packages/datadog-plugin-@(${PLUGINS})/test/**/*.spec.js\" --exclude \"packages/datadog-plugin-@(${PLUGINS})/test/integration-test/**/*.spec.js\"",
+    "test:shimmer": "mocha \"packages/datadog-shimmer/test/**/*.spec.js\"",
+    "test:shimmer:ci": "nyc -- npm run test:shimmer",
+    "verify:workflow-job-names": "node scripts/verify-workflow-job-names.js",
+    "verify-exercised-tests": "node scripts/verify-exercised-tests.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DataDog/dd-trace-js.git"
+  },
+  "keywords": [
+    "depup",
+    "dependency-bumped",
+    "updated-deps",
+    "dd-trace",
+    "datadog",
+    "trace",
+    "tracing",
+    "profile",
+    "profiler",
+    "profiling",
+    "opentracing",
+    "apm"
+  ],
+  "author": "Datadog Inc. <info@datadoghq.com>",
+  "license": "(Apache-2.0 OR BSD-3-Clause)",
+  "bugs": {
+    "url": "https://github.com/DataDog/dd-trace-js/issues"
+  },
+  "homepage": "https://github.com/DataDog/dd-trace-js#readme",
+  "engines": {
+    "node": ">=18 <26"
+  },
+  "files": [
+    "/package.json",
+    "ci/**/*",
+    "cypress/**/*",
+    "esbuild.js",
+    "ext/**/*",
+    "index.d.ts",
+    "index.js",
+    "init.js",
+    "initialize.mjs",
+    "LICENSE-3rdparty.csv",
+    "LICENSE",
+    "LICENSE.Apache",
+    "LICENSE.BSD3",
+    "loader-hook.mjs",
+    "packages/*/index.js",
+    "packages/*/lib/**/*",
+    "packages/*/src/**/*",
+    "packages/datadog-instrumentations/orchestrion.yml",
+    "README.md",
+    "register.js",
+    "scripts/preinstall.js",
+    "vendor/dist/**/*.d.ts",
+    "vendor/dist/**/*.js",
+    "vendor/dist/**/*.wasm",
+    "vendor/dist/**/LICENSE",
+    "version.js",
+    "changes.json"
+  ],
+  "dependencies": {
+    "dc-polyfill": "^0.1.10",
+    "import-in-the-middle": "^3.0.0"
+  },
+  "optionalDependencies": {
+    "@datadog/libdatadog": "0.8.1",
+    "@datadog/native-appsec": "11.0.1",
+    "@datadog/native-iast-taint-tracking": "4.1.0",
+    "@datadog/native-metrics": "3.1.1",
+    "@datadog/openfeature-node-server": "^1.1.0",
+    "@datadog/pprof": "5.13.5",
+    "@datadog/wasm-js-rewriter": "5.0.1",
+    "@opentelemetry/api": ">=1.0.0 <1.10.0",
+    "@opentelemetry/api-logs": "<1.0.0",
+    "oxc-parser": "^0.116.0"
+  },
+  "devDependencies": {
+    "@actions/core": "^3.0.0",
+    "@actions/github": "^9.0.0",
+    "@babel/helpers": "^7.28.6",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.39.2",
+    "@msgpack/msgpack": "^3.1.3",
+    "@openfeature/core": "^1.8.1",
+    "@openfeature/server-sdk": "~1.20.0",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^18.19.106",
+    "@types/sinon": "^21.0.0",
+    "axios": "^1.13.4",
+    "benchmark": "^2.1.4",
+    "body-parser": "^2.2.2",
+    "bun": "1.3.10",
+    "codeowners-audit": "^2.7.1",
+    "eslint": "^9.39.2",
+    "eslint-plugin-cypress": "^6.1.0",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jsdoc": "^62.5.0",
+    "eslint-plugin-mocha": "^11.2.0",
+    "eslint-plugin-n": "^17.23.2",
+    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-unicorn": "^63.0.0",
+    "express": "^5.1.0",
+    "glob": "^10.4.5",
+    "globals": "^17.2.0",
+    "graphql": "*",
+    "husky": "^9.1.7",
+    "jszip": "^3.10.1",
+    "mocha": "^11.6.0",
+    "mocha-junit-reporter": "^2.2.1",
+    "mocha-multi-reporters": "^1.5.1",
+    "multer": "^2.1.1",
+    "nock": "^13.5.6",
+    "nyc": "^18.0.0",
+    "octokit": "^5.0.3",
+    "opentracing": ">=0.14.7",
+    "p-limit": "^7.2.0",
+    "proxyquire": "^2.1.3",
+    "retry": "^0.13.1",
+    "semifies": "^1.0.0",
+    "semver": "^7.7.2",
+    "sinon": "^21.0.2",
+    "tiktoken": "^1.0.21",
+    "typescript": "^5.9.2",
+    "workerpool": "^10.0.0",
+    "yaml": "^2.8.0",
+    "yarn-deduplicate": "^6.0.2"
+  },
+  "depup": {
+    "changes": {},
+    "depsUpdated": 0,
+    "originalPackage": "dd-trace",
+    "originalVersion": "5.90.0",
+    "processedAt": "2026-03-17T19:31:21.190Z",
+    "smokeTest": "passed"
+  }
+}

package/packages/datadog-code-origin/index.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const { getEnvironmentVariable } = require('../dd-trace/src/config/helper')
+const { parseUserLandFrames } = require('../dd-trace/src/plugins/util/stacktrace')
+
+const ENTRY_SPAN_STACK_FRAMES_LIMIT = 1
+const EXIT_SPAN_STACK_FRAMES_LIMIT =
+  Number(getEnvironmentVariable('_DD_CODE_ORIGIN_FOR_SPANS_EXIT_SPAN_MAX_USER_FRAMES')) || 8
+
+module.exports = {
+  entryTags,
+  exitTags,
+}
+
+/**
+ * @param {Function} [topOfStackFunc] - A function present in the current stack, above which no stack frames should be
+ *   collected.
+ * @returns {Record<string, string>}
+ */
+function entryTags (topOfStackFunc) {
+  return tag('entry', ENTRY_SPAN_STACK_FRAMES_LIMIT, topOfStackFunc)
+}
+
+/**
+ * @param {Function} [topOfStackFunc] - A function present in the current stack, above which no stack frames should be
+ *   collected.
+ * @returns {Record<string, string>}
+ */
+function exitTags (topOfStackFunc) {
+  return tag('exit', EXIT_SPAN_STACK_FRAMES_LIMIT, topOfStackFunc)
+}
+
+/**
+ * @param {'entry'|'exit'} type - The type of code origin.
+ * @param {number} limit - The maximum number of stack frames to include in the tags.
+ * @param {Function} [topOfStackFunc] - A function present in the current stack, above which no stack frames should be
+ *   collected.
+ * @returns {Record<string, string>}
+ */
+function tag (type, limit, topOfStackFunc) {
+  // The `Error.prepareStackTrace` API doesn't support resolving source maps.
+  // Fall back to manually parsing the stack trace.
+  const originalLimit = Error.stackTraceLimit
+  Error.stackTraceLimit = Infinity
+  const dummy = {}
+  Error.captureStackTrace(dummy, topOfStackFunc)
+  const frames = parseUserLandFrames(dummy.stack, limit)
+  Error.stackTraceLimit = originalLimit
+
+  const tags = {
+    '_dd.code_origin.type': type,
+  }
+  for (let i = 0; i < frames.length; i++) {
+    const frame = frames[i]
+    tags[`_dd.code_origin.frames.${i}.file`] = frame.fileName
+    tags[`_dd.code_origin.frames.${i}.line`] = frame.lineNumber
+    tags[`_dd.code_origin.frames.${i}.column`] = frame.columnNumber
+    if (frame.methodName || frame.functionName) {
+      tags[`_dd.code_origin.frames.${i}.method`] = frame.methodName || frame.functionName
+    }
+    if (frame.typeName) {
+      tags[`_dd.code_origin.frames.${i}.type`] = frame.typeName
+    }
+  }
+  return tags
+}

package/packages/datadog-core/index.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const { storage } = require('./src/storage')
+
+module.exports = { storage }

package/packages/datadog-core/src/storage.js

@@ -0,0 +1,132 @@
+'use strict'
+
+const { AsyncLocalStorage } = require('async_hooks')
+
+/**
+ * This is exactly the same as AsyncLocalStorage, with the exception that it
+ * uses a WeakMap to store the store object. This is because ALS stores the
+ * store object as a property of the resource object, which causes all sorts
+ * of problems with logging and memory. We substitute the `store` object with
+ * a "handle" object, which is used as a key in a WeakMap, where the values
+ * are the real store objects.
+ *
+ * @template T
+ * @typedef {Record<string, T>} Store
+ */
+class DatadogStorage extends AsyncLocalStorage {
+  /**
+   * @param {Store<unknown>} [store]
+   * @override
+   */
+  enterWith (store) {
+    const handle = {}
+    stores.set(handle, store)
+    super.enterWith(handle)
+  }
+
+  /**
+   * This is method is a passthrough to the real `getStore()`, so that, when we
+   * need it, we can use the handle rather than our mapped store.
+   *
+   * It's only here because stores are currently used for a bunch of things,
+   * and we don't want to hold on to all of them in spans
+   * (see opentracing/span.js). Using a namespaced storage for spans would
+   * solve this.
+   *
+   * TODO: Refactor the Scope class to use a span-only store and remove this.
+   *
+   * @returns {Store<unknown>}
+   */
+  getHandle () {
+    return super.getStore()
+  }
+
+  /**
+   * Here, we replicate the behavior of the original `getStore()` method by
+   * passing in the handle, which we retrieve by calling it on super. Handles
+   * retrieved through `getHandle()` can also be passed in to be used as the
+   * key. This is useful if you've stashed a handle somewhere and want to
+   * retrieve the store with it.
+   * @param {object} [handle]
+   * @returns {Store<unknown> | undefined}
+   * @override
+   */
+  getStore (handle) {
+    if (!handle) {
+      handle = super.getStore()
+    }
+    if (handle) {
+      return stores.get(handle)
+    }
+  }
+}
+
+// To handle all versions always correct, feature detect AsyncContextFrame and
+// fallback to manual approach if not active. With ACF `run` delegates to
+// `enterWith`, without ACF `run` does not.
+const isACFActive = (() => {
+  let active = false
+  const als = new AsyncLocalStorage()
+  als.enterWith = () => { active = true }
+  als.run(1, () => {})
+  als.disable()
+  return active
+})()
+
+if (!isACFActive) {
+  const superGetStore = AsyncLocalStorage.prototype.getStore
+  const superEnterWith = AsyncLocalStorage.prototype.enterWith
+
+  /**
+   * Override the `run` method to manually call `enterWith` and `getStore`
+   * when not using AsyncContextFrame.
+   *
+   * Without ACF, super.run() won't call this.enterWith(), so the WeakMap handle
+   * is never created and getStore() would fail.
+   *
+   * @template R
+   * @template {unknown[]} TArgs
+   * @param {Store<unknown>} store
+   * @param {(...args: TArgs) => R} fn
+   * @param {TArgs} args
+   * @returns {R}
+   * @override
+   */
+  DatadogStorage.prototype.run = function run (store, fn, ...args) {
+    const prior = superGetStore.call(this)
+    this.enterWith(store)
+    try {
+      return Reflect.apply(fn, null, args)
+    } finally {
+      superEnterWith.call(this, prior)
+    }
+  }
+}
+
+/**
+ * This is the map from handles to real stores, used in the class above.
+ * @type {WeakMap<WeakKey, Store<unknown>|undefined>}
+ */
+const stores = new WeakMap()
+
+/**
+ * For convenience, we use the `storage` function as a registry of namespaces
+ * corresponding to DatadogStorage instances. This lets us have separate
+ * storages for separate purposes.
+ * @type {Map<string, DatadogStorage>}
+ */
+const storages = Object.create(null)
+
+/**
+ *
+ * @param {string} namespace The namespace to use
+ * @returns {DatadogStorage}
+ */
+function storage (namespace) {
+  if (!storages[namespace]) {
+    storages[namespace] = new DatadogStorage()
+  }
+  return storages[namespace]
+}
+
+module.exports = { storage, isACFActive }

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

@@ -0,0 +1,14 @@
+'use strict'
+
+module.exports = function kebabcase (str) {
+  if (typeof str !== 'string') {
+    throw new TypeError('Expected a string')
+  }
+
+  return str
+    .trim()
+    .replaceAll(/([a-z])([A-Z])/g, '$1-$2') // Convert camelCase to kebab-case
+    .replaceAll(/[\s_]+/g, '-') // Replace spaces and underscores with a single dash
+    .replaceAll(/^-+|-+$/g, '') // Trim leading and trailing dashes
+    .toLowerCase()
+}

package/packages/datadog-core/src/utils/src/parse-tags.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const digitRegex = /^\d+$/
+
+/**
+ * Converts a flat object of tags into a nested object. For example:
+ *   { 'a.b.c': 'value' } -> { a: { b: { c: 'value' } } }
+ * Also supports array-keys. For example:
+ *   { 'a.0.b': 'value' } -> { a: [{ b: 'value' }] }
+ *
+ * @param {object} tags - Key/value pairs of tags
+ * @returns Object - Parsed tags
+ */
+module.exports = function parseTags (tags) {
+  const parsedTags = {}
+  for (const [tag, value] of Object.entries(tags)) {
+    const keys = tag.split('.')
+    let current = parsedTags
+    let depth = 0
+    for (const key of keys) {
+      if (!current[key]) {
+        if (depth === keys.length - 1) {
+          current[key] = value
+          break
+        }
+        current[key] = keys[depth + 1]?.match(digitRegex) ? [] : {}
+      }
+      current = current[key]
+      depth++
+    }
+  }
+  return parsedTags
+}

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

@@ -0,0 +1,11 @@
+'use strict'
+
+module.exports = function pick (object, props) {
+  const result = {}
+  for (const prop of props) {
+    if (Object.hasOwn(object, prop)) {
+      result[prop] = object[prop]
+    }
+  }
+  return result
+}