dd-trace 6.10.0 → 6.12.0

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

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

@@ -14,8 +14,10 @@ const {
   GRPC_STATUS_CODE,
 } = require('../../../ext/tags')
 const { ORIGIN_KEY, TOP_LEVEL_KEY, SVC_SRC_KEY, GRPC_STATUS_NAMES } = require('./constants')
+const id = require('./id')
 
 const GRPC_STATUS_CODE_MAP = Object.fromEntries(GRPC_STATUS_NAMES.map((name, i) => [name, String(i)]))
+const ZERO_ID = id('0')
 const { version } = require('./pkg')
 const processTags = require('./process-tags')
 
@@ -150,9 +152,24 @@ class SpanAggKey {
 }
 
 class SpanBuckets extends Map {
+  #includeTraceRoot
+
+  /**
+   * @param {boolean} [includeTraceRoot]
+   */
+  constructor (includeTraceRoot = false) {
+    super()
+    this.#includeTraceRoot = includeTraceRoot
+  }
+
   forSpan (span) {
     const aggKey = new SpanAggKey(span)
-    const key = aggKey.toString()
+    const baseKey = aggKey.toString()
+    const parentId = span.parent_id
+    if (this.#includeTraceRoot && parentId !== undefined && parentId !== null) {
+      aggKey.isTraceRoot = parentId.equals(ZERO_ID)
+    }
+    const key = this.#includeTraceRoot ? `${baseKey},${aggKey.isTraceRoot}` : baseKey
 
     if (!this.has(key)) {
       this.set(key, new SpanAggStats(aggKey))
@@ -163,9 +180,19 @@ class SpanBuckets extends Map {
 }
 
 class TimeBuckets extends Map {
+  #includeTraceRoot
+
+  /**
+   * @param {boolean} [includeTraceRoot]
+   */
+  constructor (includeTraceRoot = false) {
+    super()
+    this.#includeTraceRoot = includeTraceRoot
+  }
+
   forTime (time) {
     if (!this.has(time)) {
-      this.set(time, new SpanBuckets())
+      this.set(time, new SpanBuckets(this.#includeTraceRoot))
     }
 
     return this.get(time)
@@ -192,7 +219,7 @@ class SpanStatsProcessor {
     const intervalMs = otlpExporter ? (flushIntervalMs ?? 10_000) : interval * 1e3
     this.interval = intervalMs / 1e3
     this.bucketSizeNs = intervalMs * 1e6
-    this.buckets = new TimeBuckets()
+    this.buckets = new TimeBuckets(Boolean(otlpExporter))
     this.hostname = os.hostname()
     this.enabled = enabled
     this.otlpExporter = otlpExporter || null

package/packages/dd-trace/src/storage-channels.js

@@ -0,0 +1,86 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+const { storage } = require('../../datadog-core')
+
+// Channels that surface tracer-storage events to interested consumers
+// (currently the wall profiler and the OTEP-4947 thread context writer).
+//
+// dd-trace:storage:enter — fires when the active legacy-storage store
+//   changes. Published by the shimmer installed in ensureChannelsActivated().
+// dd-trace:storage:before — fires from an async_hooks "before" callback in
+//   non-AsyncContextFrame mode. Used by the wall profiler to refresh the
+//   sample context at the start of each async resource callback. Has no
+//   publisher in ACF mode.
+// dd-trace:span:finish, dd-trace:span:tags:update — published by the
+//   tracer core (opentracing/span.js). Re-exported here as a convenience
+//   so consumers have a single import path for storage-related channels.
+const enterCh = dc.channel('dd-trace:storage:enter')
+const beforeCh = dc.channel('dd-trace:storage:before')
+const spanFinishCh = dc.channel('dd-trace:span:finish')
+const tagsUpdateCh = dc.channel('dd-trace:span:tags:update')
+
+function getActiveSpan () {
+  const store = storage('legacy').getStore()
+  return store && store.span
+}
+
+let channelsActivated = false
+// Idempotent. The asyncContextFrameEnabled argument from the first caller
+// wins; subsequent calls are no-ops regardless of their argument. In
+// practice all callers observe the same global ACF state.
+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 consumers of these channels care 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')
+    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
+      }
+    })
+  }
+
+  channelsActivated = true
+}
+
+module.exports = {
+  enterCh,
+  beforeCh,
+  spanFinishCh,
+  tagsUpdateCh,
+  getActiveSpan,
+  ensureChannelsActivated,
+}