dd-trace 6.9.0 → 6.11.0

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

@@ -8,17 +8,18 @@ const { getLageTestSessionName } = require('../../ci-visibility/lage')
 const log = require('../../log')
 const { getEnvironmentVariable, getValueFromEnvSources } = require('../../config/helper')
 const { getSegment } = require('../../util')
+const { parse } = require('../../../../../vendor/dist/jest-docblock')
 const satisfies = require('../../../../../vendor/dist/semifies')
 
 const istanbul = require('../../../../../vendor/dist/istanbul-lib-coverage')
 
+const { writeDatadogParentId, writeDatadogTraceId } = require('../../carrier')
 const id = require('../../id')
 const {
   incrementCountMetric,
   TELEMETRY_GIT_COMMIT_SHA_DISCREPANCY,
   TELEMETRY_GIT_SHA_MATCH,
 } = require('../../ci-visibility/telemetry')
-
 const { SPAN_TYPE, RESOURCE_NAME, SAMPLING_PRIORITY } = require('../../../../../ext/tags')
 const { SAMPLING_RULE_DECISION } = require('../../constants')
 const { AUTO_KEEP } = require('../../../../../ext/priority')
@@ -195,6 +196,8 @@ const VITEST_WORKER_TRACE_PAYLOAD_CODE = 100
 const VITEST_WORKER_COVERAGE_PAYLOAD_CODE = 101
 const VITEST_WORKER_LOGS_PAYLOAD_CODE = 102
 const VITEST_WORKER_TELEMETRY_PAYLOAD_CODE = 103
+const VITEST_WORKER_EFD_SUITE_ADMISSION_REQUEST_CODE = 104
+const VITEST_WORKER_EFD_SUITE_ADMISSION_RESPONSE_CODE = 105
 
 const TEST_IS_TEST_FRAMEWORK_WORKER = 'test.is_test_framework_worker'
 
@@ -489,6 +492,8 @@ module.exports = {
   VITEST_WORKER_COVERAGE_PAYLOAD_CODE,
   VITEST_WORKER_LOGS_PAYLOAD_CODE,
   VITEST_WORKER_TELEMETRY_PAYLOAD_CODE,
+  VITEST_WORKER_EFD_SUITE_ADMISSION_REQUEST_CODE,
+  VITEST_WORKER_EFD_SUITE_ADMISSION_RESPONSE_CODE,
   TEST_IS_TEST_FRAMEWORK_WORKER,
   TEST_SOURCE_START,
   TEST_SKIPPED_BY_ITR,
@@ -504,6 +509,7 @@ module.exports = {
   getTestParametersString,
   finishAllTraceSpans,
   getTestParentSpan,
+  isMarkedAsUnskippable,
   getTestSuitePath,
   getCodeOwnersFileEntries,
   getCodeOwnersForFilename,
@@ -544,6 +550,7 @@ module.exports = {
   removeInvalidMetadata,
   parseAnnotations,
   getIsFaultyEarlyFlakeDetection,
+  getFailedTestReplayPromise,
   TEST_BROWSER_DRIVER,
   TEST_BROWSER_DRIVER_VERSION,
   TEST_BROWSER_NAME,
@@ -844,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()
     }
   }
@@ -901,10 +908,10 @@ function setRumTestCorrelation (context, activeSpan) {
  * @returns {import('../../opentracing/span_context')}
  */
 function getTestParentSpan (tracer, testExecutionId) {
-  return tracer.extract('text_map', {
-    'x-datadog-trace-id': testExecutionId || id().toString(10),
-    'x-datadog-parent-id': '0000000000000000',
-  })
+  const carrier = /** @type {Record<string, unknown>} */ ({})
+  writeDatadogTraceId(carrier, testExecutionId || id().toString(10))
+  writeDatadogParentId(carrier, '0000000000000000')
+  return tracer.extract('text_map', carrier)
 }
 
 function getTestCommonTags (name, suite, version, testFramework) {
@@ -941,6 +948,62 @@ function getTestSuitePath (testSuiteAbsolutePath, sourceRoot) {
   return testSuitePath.replaceAll(path.sep, '/')
 }
 
+const globalDocblockRegExp = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/
+const MAX_COMMENTS_CHECKED = 10
+
+function isMarkedAsUnskippable (test) {
+  let testSource
+
+  try {
+    testSource = fs.readFileSync(test.path, 'utf8')
+  } catch {
+    return false
+  }
+
+  const re = globalDocblockRegExp
+  re.lastIndex = 0
+  let commentsChecked = 0
+
+  while (testSource.length) {
+    const match = re.exec(testSource)
+    if (!match) break
+    const comment = match[1]
+
+    let docblocks
+    try {
+      docblocks = parse(comment)
+    } catch {
+      // Skip unparsable comment and continue scanning
+      if (commentsChecked++ >= MAX_COMMENTS_CHECKED) {
+        return false
+      }
+      continue
+    }
+
+    if (docblocks?.datadog) {
+      try {
+        // @ts-expect-error The datadog type is defined by us and may only be a string.
+        return JSON.parse(docblocks.datadog).unskippable
+      } catch {
+        // If the @datadog block comment is present but malformed, we'll run the suite
+        log.warn('@datadog block comment is malformed.')
+        return true
+      }
+    }
+
+    if (commentsChecked++ >= MAX_COMMENTS_CHECKED) {
+      return false
+    }
+
+    // To stop as soon as no doc blocks are found, slice the source. That way the
+    // regexp works by using the `^` anchor. Without it, it would continue
+    // scanning the rest of the file.
+    testSource = testSource.slice(match[0].length)
+  }
+
+  return false
+}
+
 const POSSIBLE_CODEOWNERS_LOCATIONS = [
   'CODEOWNERS',
   '.github/CODEOWNERS',
@@ -1376,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()
@@ -1433,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()) {
@@ -1542,6 +1601,22 @@ function parseAnnotations (annotations) {
   }, {})
 }
 
+/**
+ * Combines the optional Failed Test Replay operations that must settle before a retry.
+ *
+ * @param {{setProbePromise?: Promise<void>, finishTestPromise?: Promise<void>}} promises
+ * @returns {Promise<void>|undefined}
+ */
+function getFailedTestReplayPromise (promises) {
+  if (promises.setProbePromise && promises.finishTestPromise) {
+    return Promise.all([
+      promises.setProbePromise,
+      promises.finishTestPromise,
+    ]).then(() => {})
+  }
+  return promises.setProbePromise || promises.finishTestPromise
+}
+
 function getIsFaultyEarlyFlakeDetection (projectSuites, testsBySuiteName, faultyThresholdPercentage) {
   let newSuites = 0
   for (const suite of projectSuites) {
@@ -1741,6 +1816,7 @@ function getPullRequestBaseBranch (pullRequestBaseBranch) {
   }
 
   const metrics = {}
+  let hasMetrics = false
   for (const candidate of candidateBranches) {
     // Find common ancestor
     const baseSha = getMergeBase(candidate, sourceBranch)
@@ -1759,6 +1835,7 @@ function getPullRequestBaseBranch (pullRequestBaseBranch) {
       ahead,
       baseSha,
     }
+    hasMetrics = true
   }
 
   function isDefaultBranch (branch) {
@@ -1767,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
@@ -1793,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
@@ -1807,6 +1885,7 @@ function getModifiedFilesFromDiff (diff) {
     if (fileMatch && fileMatch.groups.file) {
       currentFile = fileMatch.groups.file
       result[currentFile] = []
+      hasModifiedFiles = true
       continue
     }
 
@@ -1825,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

@@ -35,6 +35,11 @@ const MANUAL_DROP = tags.MANUAL_DROP
 
 const contexts = new WeakMap()
 const requests = new WeakMap()
+const statusCodeRangesPattern = /^[1-5]\d{2}(?:-[1-5]\d{2})?(?:,[1-5]\d{2}(?:-[1-5]\d{2})?)*$/
+const whitespacePattern = /\s/g
+const MAX_HTTP_STATUS_CODE = 599
+
+/** @typedef {(code: number) => boolean} StatusValidator */
 
 // TODO: change this to no longer rely on creating a dummy plugin to be able to access startSpan
 function createWebPlugin (tracer, config = {}) {
@@ -371,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.
@@ -559,13 +567,59 @@ function isNot500ErrorCode (code) {
   return code < 500
 }
 
+/**
+ * @param {{ validateStatus?: unknown, DD_TRACE_HTTP_SERVER_ERROR_STATUSES?: unknown }} config
+ * @returns {StatusValidator}
+ */
 function getStatusValidator (config) {
   if (typeof config.validateStatus === 'function') {
-    return config.validateStatus
+    return /** @type {StatusValidator} */ (config.validateStatus)
   } else if (config.hasOwnProperty('validateStatus')) {
     log.error('Expected `validateStatus` to be a function.')
   }
-  return isNot500ErrorCode
+
+  const { DD_TRACE_HTTP_SERVER_ERROR_STATUSES } = config
+  if (DD_TRACE_HTTP_SERVER_ERROR_STATUSES === undefined) return isNot500ErrorCode
+  if (typeof DD_TRACE_HTTP_SERVER_ERROR_STATUSES !== 'string') {
+    log.error('Expected `DD_TRACE_HTTP_SERVER_ERROR_STATUSES` to be a string.')
+    return isNot500ErrorCode
+  }
+  if (DD_TRACE_HTTP_SERVER_ERROR_STATUSES === '500-599') return isNot500ErrorCode
+
+  const normalized = DD_TRACE_HTTP_SERVER_ERROR_STATUSES.replaceAll(whitespacePattern, '')
+  if (normalized === '500-599') return isNot500ErrorCode
+  if (!statusCodeRangesPattern.test(normalized)) {
+    log.error(
+      '`DD_TRACE_HTTP_SERVER_ERROR_STATUSES` must contain comma-separated status codes or ranges from 100 to 599.'
+    )
+    return isNot500ErrorCode
+  }
+
+  const errorStatusCodes = new Uint8Array(MAX_HTTP_STATUS_CODE + 1)
+  const ranges = normalized.split(',')
+  for (const range of ranges) {
+    const separator = range.indexOf('-')
+    if (separator === -1) {
+      errorStatusCodes[Number(range)] = 1
+      continue
+    }
+
+    const first = Number(range.slice(0, separator))
+    const second = Number(range.slice(separator + 1))
+    const start = Math.min(first, second)
+    const end = Math.max(first, second)
+    errorStatusCodes.fill(1, start, end + 1)
+  }
+
+  /**
+   * @param {number} code
+   * @returns {boolean}
+   */
+  function isValidStatusCode (code) {
+    return errorStatusCodes[code] !== 1
+  }
+
+  return isValidStatusCode
 }
 
 const noop = () => {}

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,
 }