dd-trace 5.121.0 → 5.122.0

package/packages/dd-trace/src/plugins/util/jest.js

@@ -68,6 +68,8 @@ function getJestTestName (test) {
 function getJestSuitesToRun (skippableSuites, originalTests, rootDir, fallbackRootDir) {
   const unskippableSuites = {}
   const forcedToRunSuites = {}
+  let hasUnskippableSuites = false
+  let hasForcedToRunSuites = false
 
   const skippedSuites = []
   const suitesToRun = []
@@ -87,11 +89,13 @@ function getJestSuitesToRun (skippableSuites, originalTests, rootDir, fallbackRo
     if (isMarkedAsUnskippable(test)) {
       suitesToRun.push(test)
       unskippableSuites[relativePath] = true
+      hasUnskippableSuites = true
       if (fallbackRelativePath !== undefined) {
         unskippableSuites[fallbackRelativePath] = true
       }
       if (skippedSuite !== undefined) {
         forcedToRunSuites[relativePath] = true
+        hasForcedToRunSuites = true
         if (fallbackRelativePath !== undefined) {
           forcedToRunSuites[fallbackRelativePath] = true
         }
@@ -105,9 +109,6 @@ function getJestSuitesToRun (skippableSuites, originalTests, rootDir, fallbackRo
     }
   }
 
-  const hasUnskippableSuites = Object.keys(unskippableSuites).length > 0
-  const hasForcedToRunSuites = Object.keys(forcedToRunSuites).length > 0
-
   if (originalTests.length) {
     // The config object is shared by all tests, so we can just take the first one
     const [test] = originalTests

package/packages/dd-trace/src/plugins/util/test.js

@@ -851,7 +851,7 @@ function getTestTypeFromFramework (testFramework) {
  */
 function finishAllTraceSpans (span) {
   for (const traceSpan of span.context()._trace.started) {
-    if (traceSpan !== span) {
+    if (traceSpan !== span && traceSpan._duration === undefined) {
       traceSpan.finish()
     }
   }
@@ -1439,10 +1439,6 @@ function addSkippedCoverageToMap (skippedCoverage, targetMap) {
   }
 }
 
-function hasSkippedCoverage (skippedCoverage) {
-  return skippedCoverage && typeof skippedCoverage === 'object' && Object.keys(skippedCoverage).length > 0
-}
-
 function getTestCoverageLinesPercentage (coverage, skippedCoverage, rootDir) {
   const executableLinesByFile = new Map()
   const coveredLinesByFile = new Map()
@@ -1496,10 +1492,10 @@ function applySkippedCoverageToFileCoverage (fileCoverage, skippedBitmap) {
  * @returns {boolean}
  */
 function applySkippedCoverageToCoverage (coverage, skippedCoverage, rootDir) {
-  if (!hasSkippedCoverage(skippedCoverage)) return false
+  const skippedCoverageByFilename = getSkippedCoverageByFilename(skippedCoverage)
+  if (skippedCoverageByFilename.size === 0) return false
 
   const coverageMap = getCoverageMap(coverage)
-  const skippedCoverageByFilename = getSkippedCoverageByFilename(skippedCoverage)
   let matched = false
 
   for (const filename of coverageMap.files()) {
@@ -1820,6 +1816,7 @@ function getPullRequestBaseBranch (pullRequestBaseBranch) {
   }
 
   const metrics = {}
+  let hasMetrics = false
   for (const candidate of candidateBranches) {
     // Find common ancestor
     const baseSha = getMergeBase(candidate, sourceBranch)
@@ -1838,6 +1835,7 @@ function getPullRequestBaseBranch (pullRequestBaseBranch) {
       ahead,
       baseSha,
     }
+    hasMetrics = true
   }
 
   function isDefaultBranch (branch) {
@@ -1846,7 +1844,7 @@ function getPullRequestBaseBranch (pullRequestBaseBranch) {
     )
   }
 
-  if (Object.keys(metrics).length === 0) {
+  if (!hasMetrics) {
     return null
   }
   // Find branch with smallest "ahead" value, preferring default branch on tie
@@ -1872,6 +1870,7 @@ function getPullRequestDiff (baseCommit, targetCommit) {
 function getModifiedFilesFromDiff (diff) {
   if (!diff) return null
   const result = {}
+  let hasModifiedFiles = false
 
   const filesRegex = /^diff --git a\/(?<file>.+) b\/(?<file2>.+)$/g
   const linesRegex = /^@@ -\d+(,\d+)? \+(?<start>\d+)(,(?<count>\d+))? @@/g
@@ -1886,6 +1885,7 @@ function getModifiedFilesFromDiff (diff) {
     if (fileMatch && fileMatch.groups.file) {
       currentFile = fileMatch.groups.file
       result[currentFile] = []
+      hasModifiedFiles = true
       continue
     }
 
@@ -1904,7 +1904,7 @@ function getModifiedFilesFromDiff (diff) {
     linesRegex.lastIndex = 0
   }
 
-  if (Object.keys(result).length === 0) {
+  if (!hasModifiedFiles) {
     return null
   }
   return result

package/packages/dd-trace/src/plugins/util/web.js

@@ -376,6 +376,9 @@ function addAllowHeaders (req, res, headers) {
   const allowHeaders = splitHeader(headers['access-control-allow-headers'])
   const requestHeaders = splitHeader(req.headers['access-control-request-headers'])
   const contextHeaders = [
+    'baggage',
+    'traceparent',
+    'tracestate',
     'x-datadog-origin',
     'x-datadog-parent-id',
     'x-datadog-sampled', // Deprecated, but still accept it in case it's sent.

package/packages/dd-trace/src/profiling/profiler.js

@@ -35,7 +35,7 @@ function profileHasMissingSourceMaps (profile) {
 }
 
 function processInfo (infos, info, type) {
-  if (Object.keys(info).length > 0) {
+  if (info !== undefined) {
     infos[type] = info
   }
 }

package/packages/dd-trace/src/profiling/profilers/space.js

@@ -66,9 +66,7 @@ class NativeSpaceProfiler {
     return profile
   }
 
-  getInfo () {
-    return {}
-  }
+  getInfo () {}
 
   encode (profile) {
     return encodeProfileAsync(profile)

package/packages/dd-trace/src/profiling/profilers/wall.js

@@ -1,13 +1,18 @@
 'use strict'
 
-const dc = require('dc-polyfill')
-
-const { storage } = require('../../../../datadog-core')
 const log = require('../../log')
 const runtimeMetrics = require('../../runtime_metrics')
 const telemetryMetrics = require('../../telemetry/metrics')
-const { isWebServerSpan, endpointNameFromTags, getStartedSpans } = require('../webspan-utils')
+const { endpointNameFromTags, finalEndpoint, getStartedSpans } = require('../webspan-utils')
 const { SAMPLING_INTERVAL } = require('../constants')
+const {
+  enterCh,
+  beforeCh,
+  spanFinishCh,
+  getActiveSpan,
+  ensureChannelsActivated,
+} = require('../../storage-channels')
+const webTagsCache = require('../../web-tags-cache')
 
 const {
   END_TIMESTAMP_LABEL,
@@ -21,21 +26,12 @@ const TRACE_ENDPOINT_LABEL = 'trace endpoint'
 
 /** @typedef {import('../../config/config-base')} TracerConfig */
 
-let beforeCh
-const enterCh = dc.channel('dd-trace:storage:enter')
-const spanFinishCh = dc.channel('dd-trace:span:finish')
-const tagsUpdateCh = dc.channel('dd-trace:span:tags:update')
 const profilerTelemetryMetrics = telemetryMetrics.manager.namespace('profilers')
 
 const ProfilingContext = Symbol('NativeWallProfiler.ProfilingContext')
 
 let kSampleCount
 
-function getActiveSpan () {
-  const store = storage('legacy').getStore()
-  return store && store.span
-}
-
 function toBigInt (spanId) {
   return spanId !== null && typeof spanId === 'object' ? spanId.toBigInt() : spanId
 }
@@ -53,58 +49,13 @@ function updateContext (context) {
   }
   if (context.webTags !== undefined && context.endpoint === undefined) {
     // endpoint may not be determined yet, but keep it as fallback
-    // if tags are not available anymore during serialization
-    context.endpoint = endpointNameFromTags(context.webTags)
-  }
-}
-
-let channelsActivated = false
-function ensureChannelsActivated (asyncContextFrameEnabled) {
-  if (channelsActivated) return
-
-  const shimmer = require('../../../../datadog-shimmer')
-
-  // We need to instrument enterWith() on the legacy storage — that's the storage
-  // carrying span data and the only one the profiler cares about.
-  const legacyStorage = storage('legacy')
-  let inRun = false
-  shimmer.wrap(legacyStorage, 'enterWith', function (original) {
-    return function (store) {
-      const retVal = original.call(this, store)
-      if (!inRun) enterCh.publish()
-      return retVal
-    }
-  })
-
-  // When not using AsyncContextFrame, we need additional instrumentation.
-  if (!asyncContextFrameEnabled) {
-    // We need async_hooks.createHook to create a "before" callback.
-    const { createHook } = require('async_hooks')
-    beforeCh = dc.channel('dd-trace:storage:before')
-    createHook({ before: () => beforeCh.publish() }).enable()
-
-    // In ACF-based implementation run() delegates to enterWith()  so it doesn't
-    // need to be separately instrumented. in non-ACF implementation run()
-    // doesn't delegate to enterWith(), so separate instrumentation is necessary.
-    shimmer.wrap(legacyStorage, 'run', function (original) {
-      return function (store, callback, ...args) {
-        const wrappedCb = shimmer.wrapFunction(callback, cb => function (...args) {
-          inRun = false
-          enterCh.publish()
-          const retVal = cb.apply(this, args)
-          inRun = true
-          return retVal
-        })
-        inRun = true
-        const retVal = original.call(this, store, wrappedCb, ...args)
-        enterCh.publish()
-        inRun = false
-        return retVal
-      }
-    })
+    // if tags are not available anymore during serialization. Only snapshot a
+    // settled value: routing tags land over the course of the request, and this
+    // field is never refreshed once set, so capturing an interim placeholder
+    // (a bare `GET`) would pin the fallback to it. Staying undefined until then
+    // just means the next sample rotation tries again.
+    context.endpoint = finalEndpoint(context.webTags)
   }
-
-  channelsActivated = true
 }
 
 class NativeWallProfiler {
@@ -216,7 +167,13 @@ class NativeWallProfiler {
         enterCh.subscribe(this.#boundEnter)
         spanFinishCh.subscribe(this.#boundSpanFinished)
         if (this.#endpointCollectionEnabled) {
-          tagsUpdateCh.subscribe(this.#boundSpanTagsUpdated)
+          // Web-tags cache publishes once per span at the moment its
+          // walk-result transitions from undefined to a real value —
+          // exactly when we need to refresh the ProfilingContext snapshot.
+          webTagsCache.resolvedCh.subscribe(this.#boundSpanTagsUpdated)
+          // Turn on the cache's own tagsUpdate subscription — it's
+          // ref-counted, so this composes with any other active consumer.
+          webTagsCache.activate()
         }
       }
     }
@@ -299,32 +256,20 @@ class NativeWallProfiler {
     let profilingContext = span[ProfilingContext]
     if (profilingContext === undefined) {
       const context = span.context()
-      const startedSpans = getStartedSpans(context)
 
       let spanId
       let rootSpanId
       if (this.#codeHotspotsEnabled) {
+        const startedSpans = getStartedSpans(context)
         spanId = context._spanId
         rootSpanId = startedSpans.length ? startedSpans[0].context()._spanId : context._spanId
       }
 
-      let webTags
-      if (this.#endpointCollectionEnabled) {
-        const tags = context.getTags()
-        if (isWebServerSpan(tags)) {
-          webTags = tags
-        } else {
-          // Get parent's context's web tags
-          const parentId = context._parentId
-          for (let i = startedSpans.length; --i >= 0;) {
-            const ispan = startedSpans[i]
-            if (ispan.context()._spanId === parentId) {
-              webTags = this.#getProfilingContext(ispan).webTags
-              break
-            }
-          }
-        }
-      }
+      // webTags is snapshotted into the sample context at getProfilingContext
+      // time; if the answer turns out to be undefined and the span later gets
+      // web-server tags, #spanTagsUpdated refreshes this field via the shared
+      // cache (see web-tags-cache.js).
+      const webTags = this.#endpointCollectionEnabled ? webTagsCache.getCachedWebTags(span) : undefined
 
       profilingContext = { spanId, rootSpanId, webTags }
       span[ProfilingContext] = profilingContext
@@ -345,14 +290,15 @@ class NativeWallProfiler {
     }
   }
 
+  // Invoked (via webTagsCache.resolvedCh) once per span at the moment the
+  // shared cache promotes a previously-undefined webTags answer into a
+  // real value. Refresh the ProfilingContext snapshot so future samples
+  // pick it up.
   #spanTagsUpdated (span) {
     if (!this.#started) return
     const profilingContext = span[ProfilingContext]
-    if (profilingContext === undefined || profilingContext.webTags !== undefined) return
-    const tags = span.context().getTags()
-    if (isWebServerSpan(tags)) {
-      profilingContext.webTags = tags
-    }
+    if (profilingContext === undefined) return
+    profilingContext.webTags = webTagsCache.getCachedWebTags(span)
   }
 
   #reportV8bug (maybeBug) {
@@ -401,7 +347,8 @@ class NativeWallProfiler {
         enterCh.unsubscribe(this.#boundEnter)
         spanFinishCh.unsubscribe(this.#boundSpanFinished)
         if (this.#endpointCollectionEnabled) {
-          tagsUpdateCh.unsubscribe(this.#boundSpanTagsUpdated)
+          webTagsCache.resolvedCh.unsubscribe(this.#boundSpanTagsUpdated)
+          webTagsCache.deactivate()
         }
         this.#profilerState = undefined
       }
@@ -470,7 +417,7 @@ class NativeWallProfiler {
     if (rootSpanId !== undefined) {
       labels[LOCAL_ROOT_SPAN_ID_LABEL] = toBigInt(rootSpanId)
     }
-    if (webTags !== undefined && Object.keys(webTags).length !== 0) {
+    if (webTags !== undefined) {
       labels[TRACE_ENDPOINT_LABEL] = endpointNameFromTags(webTags)
     } else if (endpoint) {
       // fallback to endpoint computed when sample was taken

package/packages/dd-trace/src/profiling/webspan-utils.js

@@ -14,6 +14,50 @@ function endpointNameFromTags (tags) {
   ].filter(Boolean).join(' ')
 }
 
+// The endpoint name a web-server span's tag bag yields changes over the span's
+// lifetime: plugins set `http.method` when the request arrives and only add
+// `http.route` (and often `resource.name`) once framework routing has resolved
+// the URL. Returns the endpoint name once its value looks stable, or undefined
+// while it is still an interim placeholder.
+//
+// Consumers that read the tag bag lazily (the wall profiler resolves endpoint
+// labels at serialization time) see the settled value for free and only need
+// this for fallbacks captured mid-request. Consumers that have to materialize
+// the value early — the OTEP-4947 thread-context writer writes it into a record
+// an out-of-process reader samples at any moment — need it to decide when
+// publishing is safe.
+//
+// The test is on the computed value rather than on which tags are present,
+// because endpointNameFromTags prefers `resource.name` over
+// `http.method` + `http.route` and some plugins seed `resource.name` with the
+// bare request method before routing resolves: datadog-plugin-next starts its
+// request span with `resource.name: req.method` and only replaces it with
+// `${req.method} ${page}` once the page is known. A value equal to the bare
+// method is therefore a placeholder no matter which tags produced it.
+function finalEndpoint (tags) {
+  if (tags == null) return
+  // Presence gate first: nothing but these two can contribute routing
+  // information, and checking them keeps the common not-yet-routed case free of
+  // the string building inside endpointNameFromTags.
+  if (tags[RESOURCE_NAME] == null && tags[HTTP_ROUTE] == null) return
+  const endpoint = endpointNameFromTags(tags)
+  if (!endpoint || endpoint === tags[HTTP_METHOD]) return
+  return endpoint
+}
+
+// The trace's started-spans list, whose first entry is the local root span by
+// repo-wide convention — priority_sampler, span_format, the wall profiler's
+// local-root-span-id label, the event plugins and the OTEP-4947 writer all read
+// it that way, and web-tags-cache walks it to find a span's parent.
+//
+// Partial flush weakens that convention for every one of them alike:
+// span_processor's _erase() replaces the list with the still-active spans only,
+// so once a trace crosses DD_TRACE_PARTIAL_FLUSH_MIN_SPANS a local root that has
+// already finished drops out, and the first entry becomes merely the oldest span
+// still running — while a finished web-server ancestor stops being reachable for
+// the parent-chain walk. Correcting it needs a local-root reference the tracer
+// core keeps across flushes; until there is one, consumers share the same skew
+// on large traces rather than each compensating differently.
 function getStartedSpans (context) {
   return context._trace.started
 }
@@ -21,5 +65,6 @@ function getStartedSpans (context) {
 module.exports = {
   isWebServerSpan,
   endpointNameFromTags,
+  finalEndpoint,
   getStartedSpans,
 }

package/packages/dd-trace/src/proxy.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const NoopProxy = require('./noop/proxy')
-const { features } = require('./feature-registry')
 const DatadogTracer = require('./tracer')
 const getConfig = require('./config')
 const { getEnvironmentVariable } = require('./config/helper')
@@ -38,9 +37,9 @@ const OFFLINE_VALIDATION_EXPORTERS = new Set([
   'playwright_worker',
   'vitest_worker',
 ])
-const FEATURE_STATE_NOOP = 0
-const FEATURE_STATE_LAZY = 1
-const FEATURE_STATE_ACTIVE = 2
+const OPENFEATURE_STATE_NOOP = 0
+const OPENFEATURE_STATE_LAZY = 1
+const OPENFEATURE_STATE_ACTIVE = 2
 
 class LazyModule {
   constructor (provider) {
@@ -91,8 +90,7 @@ function defineLazily (obj, property, getClass, ...args) {
 }
 
 class Tracer extends NoopProxy {
-  /** @type {Record<string, number> | undefined} */
-  #featureStates
+  #openfeatureState = OPENFEATURE_STATE_NOOP
 
   constructor () {
     super()
@@ -115,12 +113,9 @@ class Tracer extends NoopProxy {
       aiguard: new LazyModule(() => require('./aiguard')),
       iast: new LazyModule(() => require('./appsec/iast')),
       llmobs: new LazyModule(() => require('./llmobs')),
+      openfeature: new LazyModule(() => require('./openfeature')),
       rewriter: new LazyModule(() => require('./appsec/iast/taint-tracking/rewriter')),
     }
-
-    for (const feature of Object.values(features)) {
-      this._modules[feature.name] = new LazyModule(feature.factory)
-    }
   }
 
   /**
@@ -213,9 +208,10 @@ class Tracer extends NoopProxy {
           DynamicInstrumentation.start(config, rc)
         }
 
-        for (const feature of Object.values(features)) {
-          feature.remoteConfig?.(rc, config, this)
-        }
+        const openfeatureRemoteConfig = require('./openfeature/remote_config')
+        const subscribeOpenfeatureToRemoteConfig = config.featureFlags.DD_FEATURE_FLAGS_ENABLED &&
+          config.featureFlags.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE === 'remote_config'
+        openfeatureRemoteConfig.enable(rc, () => this.openfeature, subscribeOpenfeatureToRemoteConfig)
       }
 
       if (config.profiling.DD_PROFILING_ENABLED === 'true') {
@@ -233,6 +229,17 @@ class Tracer extends NoopProxy {
         }
       }
 
+      // Experimental: mirror the active trace ID, span ID and endpoint into
+      // an OTEP-4947 thread-local context record an out-of-process eBPF
+      // reader can consume.
+      if (config.DD_TRACE_OTEL_CTX_ENABLED) {
+        try {
+          require('./otel-thread-ctx').start()
+        } catch (e) {
+          log.error('Error starting OTEP-4947 thread context writer', e)
+        }
+      }
+
       // OTel logs/metrics pipelines must be initialized BEFORE runtimeMetrics.start so that
       // when the OTLP runtime metrics module calls metrics.getMeterProvider(), it gets the
       // real provider, otherwise instruments register on the noop provider and never export.
@@ -305,28 +312,32 @@ class Tracer extends NoopProxy {
   }
 
   /**
-   * @param {(typeof features)[string]} feature
+   * `tracer.openfeature` is only reachable through this proxy. SSI itself (auto-injecting
+   * the tracer, resolving the vendored provider regardless of the customer's own
+   * `node_modules` layout) is unaffected -- that is what this PR fixes. The remaining gap is
+   * narrower: there is no `dd-trace-api` handoff for `openfeature` yet (see
+   * `packages/datadog-plugin-dd-trace-api`), so an application that calls into the tracer
+   * exclusively through the `dd-trace-api` shim -- instead of `require('dd-trace')` -- cannot
+   * reach the flagging provider through that shim.
+   *
    * @param {import('./config/config-base')} config
    */
-  #enableFeature (feature, config) {
-    const states = this.#featureStates ??= {}
-    const state = states[feature.name] ?? FEATURE_STATE_NOOP
+  #enableOpenfeature (config) {
+    if (this.#openfeatureState !== OPENFEATURE_STATE_NOOP) return
+    this.#openfeatureState = OPENFEATURE_STATE_LAZY
 
-    if (state === FEATURE_STATE_ACTIVE || state === FEATURE_STATE_LAZY) return
-    states[feature.name] = FEATURE_STATE_LAZY
-
-    Reflect.defineProperty(this, feature.name, {
+    Reflect.defineProperty(this, 'openfeature', {
       get: () => {
-        const Provider = feature.provider()
-        const provider = new Provider(this._tracer, config)
+        const FlaggingProvider = require('./openfeature/flagging_provider')
+        const provider = new FlaggingProvider(this._tracer, config)
 
-        this._modules[feature.name].enable(config)
-        Reflect.defineProperty(this, feature.name, {
+        this._modules.openfeature.enable(config)
+        Reflect.defineProperty(this, 'openfeature', {
           value: provider,
           configurable: true,
           enumerable: true,
         })
-        states[feature.name] = FEATURE_STATE_ACTIVE
+        this.#openfeatureState = OPENFEATURE_STATE_ACTIVE
         return provider
       },
       configurable: true,
@@ -373,9 +384,7 @@ class Tracer extends NoopProxy {
       this._modules.llmobs.disable()
     }
 
-    for (const feature of Object.values(features)) {
-      if (feature.isEnabled(config)) this.#enableFeature(feature, config)
-    }
+    if (config.featureFlags.DD_FEATURE_FLAGS_ENABLED) this.#enableOpenfeature(config)
 
     if (this._tracingInitialized) {
       this._tracer.configure(config)

package/packages/dd-trace/src/ritm.js

@@ -20,6 +20,7 @@ const origRequire = Module.prototype.require
 module.exports = Hook
 
 let moduleHooks = Object.create(null)
+let hookedModuleCount = 0
 let cache = Object.create(null)
 let patching = Object.create(null)
 let patchedRequire = null
@@ -64,6 +65,7 @@ function Hook (modules, options, onrequire) {
         hooks.push(onrequire)
       } else {
         moduleHooks[mod] = [onrequire]
+        hookedModuleCount++
       }
     }
   }
@@ -205,6 +207,7 @@ Hook.reset = function () {
   patching = Object.create(null)
   cache = Object.create(null)
   moduleHooks = Object.create(null)
+  hookedModuleCount = 0
 }
 
 function findProjectRoot (startDir) {
@@ -221,16 +224,20 @@ function findProjectRoot (startDir) {
 
 Hook.prototype.unhook = function () {
   for (const mod of this.modules) {
-    const hooks = (moduleHooks[mod] || []).filter(hook => hook !== this.onrequire)
+    const registeredHooks = moduleHooks[mod]
+    if (registeredHooks === undefined) continue
+
+    const hooks = registeredHooks.filter(hook => hook !== this.onrequire)
 
     if (hooks.length > 0) {
       moduleHooks[mod] = hooks
     } else {
       delete moduleHooks[mod]
+      hookedModuleCount--
     }
   }
 
-  if (Object.keys(moduleHooks).length === 0) {
+  if (hookedModuleCount === 0) {
     Hook.reset()
   }
 }

package/packages/dd-trace/src/serverless.js

@@ -42,7 +42,44 @@ function isInServerlessEnvironment () {
   return inAWSLambda || isGCPFunction || isAzureFunction
 }
 
+/**
+ * Gets tags describing the serverless platform where the tracer is running.
+ *
+ * @returns {string[]|undefined}
+ */
+function getServerlessPlatformTags () {
+  if (getEnvironmentVariable('VERCEL') === '1') {
+    return getVercelPlatformTags()
+  }
+}
+
+/**
+ * @returns {string[]|undefined}
+ */
+function getVercelPlatformTags () {
+  let tags
+  const projectId = getEnvironmentVariable('VERCEL_PROJECT_ID')
+  if (projectId) {
+    tags = ['vercel.project_id', projectId]
+  }
+
+  const environment = getEnvironmentVariable('VERCEL_ENV')
+  if (environment) {
+    tags ??= []
+    tags.push('vercel.environment', environment)
+  }
+
+  const region = getEnvironmentVariable('VERCEL_REGION')
+  if (region) {
+    tags ??= []
+    tags.push('vercel.region', region)
+  }
+
+  return tags
+}
+
 module.exports = {
+  getServerlessPlatformTags,
   getIsGCPFunction,
   getIsAzureFunction,
   enableGCPPubSubPushSubscription,

package/packages/dd-trace/src/span_format.js

@@ -450,3 +450,4 @@ function isUrl (obj) {
 }
 
 module.exports = format
+module.exports.addError = extractError