dd-trace 5.53.0 → 5.55.0

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

@@ -1,10 +1,9 @@
 const { performance, constants, PerformanceObserver } = require('perf_hooks')
-const { END_TIMESTAMP_LABEL, SPAN_ID_LABEL, LOCAL_ROOT_SPAN_ID_LABEL } = require('./shared')
+const { END_TIMESTAMP_LABEL, SPAN_ID_LABEL, LOCAL_ROOT_SPAN_ID_LABEL, encodeProfileAsync } = require('./shared')
 const { Function, Label, Line, Location, Profile, Sample, StringTable, ValueType } = require('pprof-format')
-const pprof = require('@datadog/pprof/')
 
 // perf_hooks uses millis, with fractional part representing nanos. We emit nanos into the pprof file.
-const MS_TO_NS = 1000000
+const MS_TO_NS = 1_000_000
 
 // While this is an "events profiler", meaning it emits a pprof file based on events observed as
 // perf_hooks events, the emitted pprof file uses the type "timeline".
@@ -50,10 +49,10 @@ class GCDecorator {
     // Create labels for all GC performance flags and kinds of GC
     for (const [key, value] of Object.entries(constants)) {
       if (key.startsWith('NODE_PERFORMANCE_GC_FLAGS_')) {
-        this.flagObj[key.substring(26).toLowerCase()] = value
+        this.flagObj[key.slice(26).toLowerCase()] = value
       } else if (key.startsWith('NODE_PERFORMANCE_GC_')) {
         // It's a constant for a kind of GC
-        const kind = key.substring(20).toLowerCase()
+        const kind = key.slice(20).toLowerCase()
         this.kindLabels[value] = labelFromStr(stringTable, kindLabelKey, kind)
       }
     }
@@ -258,6 +257,12 @@ class EventSerializer {
   }
 }
 
+function add (items) {
+  for (const item of items.getEntries()) {
+    this.eventHandler(item)
+  }
+}
+
 /**
  * Class that sources timeline events through Node.js performance measurement APIs.
  */
@@ -272,12 +277,6 @@ class NodeApiEventSource {
     // if already started, do nothing
     if (this.observer) return
 
-    function add (items) {
-      for (const item of items.getEntries()) {
-        this.eventHandler(item)
-      }
-    }
-
     this.observer = new PerformanceObserver(add.bind(this))
     this.observer.observe({ entryTypes: this.entryTypes })
   }
@@ -381,17 +380,15 @@ class EventsProfiler {
       }
     }
 
-    if (options.codeHotspotsEnabled) {
+    this.eventSource = options.codeHotspotsEnabled
       // Use Datadog instrumentation to collect events with span IDs. Still use
       // Node API for GC events.
-      this.eventSource = new CompositeEventSource([
+      ? new CompositeEventSource([
         new DatadogInstrumentationEventSource(eventHandler, eventFilter),
         new NodeApiEventSource(filteringEventHandler, ['gc'])
       ])
-    } else {
       // Use Node API instrumentation to collect events without span IDs
-      this.eventSource = new NodeApiEventSource(filteringEventHandler)
-    }
+      : new NodeApiEventSource(filteringEventHandler)
   }
 
   start () {
@@ -412,7 +409,7 @@ class EventsProfiler {
   }
 
   encode (profile) {
-    return pprof.encode(profile())
+    return encodeProfileAsync(profile())
   }
 }
 

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

@@ -36,6 +36,10 @@ function getNonJSThreadsLabels () {
   return { [THREAD_NAME_LABEL]: 'Non-JS threads', [THREAD_ID_LABEL]: 'NA', [OS_THREAD_ID_LABEL]: 'NA' }
 }
 
+function encodeProfileAsync (profile) {
+  return profile.encodeAsync().then(Buffer.from)
+}
+
 module.exports = {
   END_TIMESTAMP_LABEL,
   THREAD_NAME_LABEL,
@@ -46,5 +50,6 @@ module.exports = {
   threadNamePrefix,
   eventLoopThreadName,
   getNonJSThreadsLabels,
-  getThreadLabels: cacheThreadLabels()
+  getThreadLabels: cacheThreadLabels(),
+  encodeProfileAsync
 }

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const { oomExportStrategies } = require('../constants')
-const { getThreadLabels } = require('./shared')
+const { encodeProfileAsync, getThreadLabels } = require('./shared')
 
 function strategiesToCallbackMode (strategies, callbackMode) {
   return strategies.includes(oomExportStrategies.ASYNC_CALLBACK) ? callbackMode.Async : 0
@@ -10,7 +10,7 @@ function strategiesToCallbackMode (strategies, callbackMode) {
 class NativeSpaceProfiler {
   constructor (options = {}) {
     this.type = 'space'
-    this._samplingInterval = options.samplingInterval || 512 * 1024
+    this._samplingInterval = options.heapSamplingInterval || 512 * 1024
     this._stackDepth = options.stackDepth || 64
     this._pprof = undefined
     this._oomMonitoring = options.oomMonitoring || {}
@@ -47,7 +47,7 @@ class NativeSpaceProfiler {
   }
 
   encode (profile) {
-    return this._pprof.encode(profile)
+    return encodeProfileAsync(profile)
   }
 
   stop () {

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

@@ -10,7 +10,8 @@ const {
   SPAN_ID_LABEL,
   LOCAL_ROOT_SPAN_ID_LABEL,
   getNonJSThreadsLabels,
-  getThreadLabels
+  getThreadLabels,
+  encodeProfileAsync
 } = require('./shared')
 
 const { isWebServerSpan, endpointNameFromTags, getStartedSpans } = require('../webspan-utils')
@@ -89,11 +90,9 @@ class NativeWallProfiler {
     this._pprof = undefined
 
     // Bind these to this so they can be used as callbacks
-    if (this._withContexts) {
-      if (this._captureSpanData) {
-        this._enter = this._enter.bind(this)
-        this._spanFinished = this._spanFinished.bind(this)
-      }
+    if (this._withContexts && this._captureSpanData) {
+      this._enter = this._enter.bind(this)
+      this._spanFinished = this._spanFinished.bind(this)
     }
     this._generateLabels = this._generateLabels.bind(this)
 
@@ -326,7 +325,7 @@ class NativeWallProfiler {
   }
 
   encode (profile) {
-    return this._pprof.encode(profile)
+    return encodeProfileAsync(profile)
   }
 
   stop () {

package/packages/dd-trace/src/profiling/ssi-heuristics.js

@@ -6,7 +6,7 @@ const dc = require('dc-polyfill')
 const log = require('../log')
 
 // If the process lives for at least 30 seconds, it's considered long-lived
-const DEFAULT_LONG_LIVED_THRESHOLD = 30000
+const DEFAULT_LONG_LIVED_THRESHOLD = 30_000
 
 /**
  * This class embodies the SSI profiler-triggering heuristics and also emits telemetry metrics about
@@ -107,10 +107,8 @@ class SSIHeuristics {
   }
 
   _maybeTriggered () {
-    if (!this.shortLived && !this.noSpan) {
-      if (typeof this.triggeredCallback === 'function') {
-        this.triggeredCallback.call(null)
-      }
+    if (!this.shortLived && !this.noSpan && typeof this.triggeredCallback === 'function') {
+      this.triggeredCallback.call(null)
     }
   }
 

package/packages/dd-trace/src/profiling/ssi-telemetry-mock-profiler.js

@@ -3,7 +3,9 @@
 const dc = require('dc-polyfill')
 const coalesce = require('koalas')
 const profileSubmittedChannel = dc.channel('datadog:profiling:mock-profile-submitted')
-const { DD_PROFILING_UPLOAD_PERIOD } = process.env
+const { getEnvironmentVariable } = require('../config-helper')
+
+const DD_PROFILING_UPLOAD_PERIOD = getEnvironmentVariable('DD_PROFILING_UPLOAD_PERIOD')
 
 let timerId
 

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

@@ -5,22 +5,30 @@ const tagger = {
     if (!tags) return {}
 
     switch (typeof tags) {
-      case 'object':
+      case 'object': {
         if (Array.isArray(tags)) {
-          return tags.reduce((prev, next) => {
-            const parts = next.split(':')
-            const key = parts.shift().trim()
-            const value = parts.join(':').trim()
-
-            if (!key || !value) return prev
+          const tagObject = {}
+          for (const tag of tags) {
+            const colon = tag.indexOf(':')
+            if (colon === -1) continue
+            const key = tag.slice(0, colon).trim()
+            const value = tag.slice(colon + 1).trim()
+            if (key.length !== 0 && value.length !== 0) {
+              tagObject[key] = value
+            }
+          }
+          return tagObject
+        }
 
-            return Object.assign(prev, { [key]: value })
-          }, {})
-        } else {
-          return tagger.parse(Object.keys(tags)
-            .filter(key => tags[key] !== undefined && tags[key] !== null)
-            .map(key => `${key}:${tags[key]}`))
+        const tagsArray = []
+        for (const [key, value] of Object.entries(tags)) {
+          if (value != null) {
+            tagsArray.push(`${key}:${value}`)
+          }
         }
+
+        return tagger.parse(tagsArray)
+      }
       case 'string':
         return tagger.parse(tags.split(','))
       default:

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

@@ -9,7 +9,7 @@ function endpointNameFromTags (tags) {
   return tags[RESOURCE_NAME] || [
     tags[HTTP_METHOD],
     tags[HTTP_ROUTE]
-  ].filter(v => v).join(' ')
+  ].filter(Boolean).join(' ')
 }
 
 function getStartedSpans (context) {

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

@@ -10,6 +10,7 @@ const telemetry = require('./telemetry')
 const nomenclature = require('./service-naming')
 const PluginManager = require('./plugin_manager')
 const NoopDogStatsDClient = require('./noop/dogstatsd')
+const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 const {
   setBaggageItem,
   getBaggageItem,
@@ -189,18 +190,16 @@ class Tracer extends NoopProxy {
 
       this._modules.rewriter.enable(config)
 
-      if (config.tracing) {
-        if (config.isManualApiEnabled) {
-          const TestApiManualPlugin = require('./ci-visibility/test-api-manual/test-api-manual-plugin')
-          this._testApiManualPlugin = new TestApiManualPlugin(this)
-          // `shouldGetEnvironmentData` is passed as false so that we only lazily calculate it
-          // This is the only place where we need to do this because the rest of the plugins
-          // are lazily configured when the library is imported.
-          this._testApiManualPlugin.configure({ ...config, enabled: true }, false)
-        }
+      if (config.tracing && config.isManualApiEnabled) {
+        const TestApiManualPlugin = require('./ci-visibility/test-api-manual/test-api-manual-plugin')
+        this._testApiManualPlugin = new TestApiManualPlugin(this)
+        // `shouldGetEnvironmentData` is passed as false so that we only lazily calculate it
+        // This is the only place where we need to do this because the rest of the plugins
+        // are lazily configured when the library is imported.
+        this._testApiManualPlugin.configure({ ...config, enabled: true }, false)
       }
       if (config.ciVisAgentlessLogSubmissionEnabled) {
-        if (process.env.DD_API_KEY) {
+        if (getEnvironmentVariable('DD_API_KEY')) {
           const LogSubmissionPlugin = require('./ci-visibility/log-submission/log-submission-plugin')
           const automaticLogPlugin = new LogSubmissionPlugin(this)
           automaticLogPlugin.configure({ ...config, enabled: true })

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

@@ -0,0 +1,40 @@
+'use strict'
+
+/**
+ * `RandomSampler` determines whether or not to sample an operation based on random chance.
+ *
+ * Use this class **only** when the operation you are sampling does **not have access**
+ * to a `Span` or its `SpanContext`.
+ *
+ * If a `Span` or its `SpanContext` **is** available, use the `Sampler` class instead as
+ * it uses a deterministic sampling algorithm consistent across all languages.
+ */
+class RandomSampler {
+  /**
+   * @param {number} rate
+   */
+  constructor (rate) {
+    this._rate = rate
+  }
+
+  /**
+   * @returns {number}
+   */
+  rate () {
+    return this._rate
+  }
+
+  /**
+   * Determines whether an operation should be sampled based on the configured sampling rate.
+   *
+   * Returns `true` if the sampling decision passes (i.e., the operation should be sampled).
+   * This happens if the sampling rate is `1` (i.e., always sample) or if a random value falls below the rate.
+   *
+   * @returns {boolean} `true` if the operation should be sampled, otherwise `false`.
+   */
+  isSampled () {
+    return this._rate === 1 || Math.random() < this._rate
+  }
+}
+
+module.exports = RandomSampler

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

@@ -4,7 +4,7 @@ const limiter = require('limiter')
 
 class RateLimiter {
   constructor (rateLimit, interval = 'second') {
-    this._rateLimit = parseInt(rateLimit)
+    this._rateLimit = Number.parseInt(rateLimit)
     this._limiter = new limiter.RateLimiter(this._rateLimit, interval)
     this._tokensRequested = 0
     this._prevIntervalTokens = 0
@@ -16,12 +16,12 @@ class RateLimiter {
     const curIntervalTokens = this._limiter.tokensThisInterval
     const allowed = this._isAllowed()
 
-    if (curIntervalStart !== this._limiter.curIntervalStart) {
+    if (curIntervalStart === this._limiter.curIntervalStart) {
+      this._tokensRequested++
+    } else {
       this._prevIntervalTokens = curIntervalTokens
       this._prevTokensRequested = this._tokensRequested
       this._tokensRequested = 1
-    } else {
-      this._tokensRequested++
     }
 
     return allowed

package/packages/dd-trace/src/remote_config/index.js

@@ -61,13 +61,9 @@ function enable (config, appsec) {
 
 function enableOrDisableAppsec (action, rcConfig, config, appsec) {
   if (typeof rcConfig.asm?.enabled === 'boolean') {
-    let shouldEnable
-
-    if (action === 'apply' || action === 'modify') {
-      shouldEnable = rcConfig.asm.enabled // take control
-    } else {
-      shouldEnable = config.appsec.enabled // give back control to local config
-    }
+    const shouldEnable = action === 'apply' || action === 'modify'
+      ? rcConfig.asm.enabled // take control
+      : config.appsec.enabled // give back control to local config
 
     if (shouldEnable) {
       appsec.enable(config)

package/packages/dd-trace/src/remote_config/manager.js

@@ -59,13 +59,17 @@ class RemoteConfigManager extends EventEmitter {
           targets_version: 0,
           // Use getter so `apply_*` can be updated async and still affect the content of `config_states`
           get config_states () {
-            return Array.from(appliedConfigs.values()).map((conf) => ({
-              id: conf.id,
-              version: conf.version,
-              product: conf.product,
-              apply_state: conf.apply_state,
-              apply_error: conf.apply_error
-            }))
+            const configs = []
+            for (const conf of appliedConfigs.values()) {
+              configs.push({
+                id: conf.id,
+                version: conf.version,
+                product: conf.product,
+                apply_state: conf.apply_state,
+                apply_error: conf.apply_error
+              })
+            }
+            return configs
           },
           has_error: false,
           error: '',
@@ -125,7 +129,7 @@ class RemoteConfigManager extends EventEmitter {
   }
 
   updateProducts () {
-    this.state.client.products = Array.from(this._handlers.keys())
+    this.state.client.products = [...this._handlers.keys()]
   }
 
   getPayload () {
@@ -246,11 +250,19 @@ class RemoteConfigManager extends EventEmitter {
       this.dispatch(toApply, 'apply')
       this.dispatch(toModify, 'modify')
 
-      this.state.cached_target_files = Array.from(this.appliedConfigs.values()).map((conf) => ({
-        path: conf.path,
-        length: conf.length,
-        hashes: Object.entries(conf.hashes).map((entry) => ({ algorithm: entry[0], hash: entry[1] }))
-      }))
+      this.state.cached_target_files = []
+
+      for (const conf of this.appliedConfigs.values()) {
+        const hashes = []
+        for (const hash of Object.entries(conf.hashes)) {
+          hashes.push({ algorithm: hash[0], hash: hash[1] })
+        }
+        this.state.cached_target_files.push({
+          path: conf.path,
+          length: conf.length,
+          hashes
+        })
+      }
     }
   }
 

package/packages/dd-trace/src/require-package-json.js

@@ -23,7 +23,7 @@ function requirePackageJson (name, module) {
     const candidate = path.join(modulePath, name, 'package.json')
     try {
       return JSON.parse(fs.readFileSync(candidate, 'utf8'))
-    } catch (e) {
+    } catch {
       continue
     }
   }

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

@@ -4,6 +4,7 @@ const path = require('path')
 const Module = require('module')
 const parse = require('module-details-from-path')
 const dc = require('dc-polyfill')
+const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 
 const origRequire = Module.prototype.require
 
@@ -60,11 +61,11 @@ function Hook (modules, options, onrequire) {
     let filename
     try {
       filename = Module._resolveFilename(request, this)
-    } catch (resolveErr) {
+    } catch {
       return _origRequire.apply(this, arguments)
     }
 
-    const core = filename.indexOf(path.sep) === -1
+    const core = !filename.includes(path.sep)
     let name, basedir, hooks
     // return known patched modules immediately
     if (cache[filename]) {
@@ -82,9 +83,8 @@ function Hook (modules, options, onrequire) {
     if (patched) {
       // If it's already patched, just return it as-is.
       return origRequire.apply(this, arguments)
-    } else {
-      patching[filename] = true
     }
+    patching[filename] = true
 
     const payload = {
       filename,
@@ -110,10 +110,10 @@ function Hook (modules, options, onrequire) {
       if (!hooks) return exports // abort if module name isn't on whitelist
       name = filename
     } else {
-      const inAWSLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined
-      const hasLambdaHandler = process.env.DD_LAMBDA_HANDLER !== undefined
+      const inAWSLambda = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined
+      const hasLambdaHandler = getEnvironmentVariable('DD_LAMBDA_HANDLER') !== undefined
       const segments = filename.split(path.sep)
-      const filenameFromNodeModule = segments.lastIndexOf('node_modules') !== -1
+      const filenameFromNodeModule = segments.includes('node_modules')
       // decide how to assign the stat
       // first case will only happen when patching an AWS Lambda Handler
       const stat = inAWSLambda && hasLambdaHandler && !filenameFromNodeModule ? { name: filename } : parse(filename)
@@ -134,7 +134,7 @@ function Hook (modules, options, onrequire) {
       let res
       try {
         res = Module._findPath(name, [basedir, ...paths])
-      } catch (e) {
+      } catch {
         // case where the file specified in package.json "main" doesn't exist
         // in this case, the file is treated as module-internal
       }

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

@@ -8,10 +8,11 @@ const { DogStatsDClient, MetricsAggregationClient } = require('../dogstatsd')
 const log = require('../log')
 const Histogram = require('../histogram')
 const { performance, PerformanceObserver } = require('perf_hooks')
+const { getEnvironmentVariable } = require('../config-helper')
 
 const { NODE_MAJOR, NODE_MINOR } = require('../../../../version')
-const { DD_RUNTIME_METRICS_FLUSH_INTERVAL = '10000' } = process.env
-const INTERVAL = parseInt(DD_RUNTIME_METRICS_FLUSH_INTERVAL, 10)
+const DD_RUNTIME_METRICS_FLUSH_INTERVAL = getEnvironmentVariable('DD_RUNTIME_METRICS_FLUSH_INTERVAL') ?? '10000'
+const INTERVAL = Number.parseInt(DD_RUNTIME_METRICS_FLUSH_INTERVAL, 10)
 
 // Node >=16 has PerformanceObserver with `gc` type, but <16.7 had a critical bug.
 // See: https://github.com/nodejs/node/issues/39548
@@ -141,7 +142,7 @@ function captureCpuUsage () {
   time = process.hrtime()
   cpuUsage = process.cpuUsage()
 
-  const elapsedMs = elapsedTime[0] * 1000 + elapsedTime[1] / 1000000
+  const elapsedMs = elapsedTime[0] * 1000 + elapsedTime[1] / 1_000_000
   const userPercent = 100 * elapsedUsage.user / 1000 / elapsedMs
   const systemPercent = 100 * elapsedUsage.system / 1000 / elapsedMs
   const totalPercent = userPercent + systemPercent
@@ -202,7 +203,7 @@ function captureGCMetrics () {
   const pause = {}
 
   for (const stat of profile.statistics) {
-    const type = stat.gcType.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase()
+    const type = stat.gcType.replaceAll(/([a-z])([A-Z])/g, '$1_$2').toLowerCase()
 
     pause[type] = pause[type] || new Histogram()
     pause[type].record(stat.cost)

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

@@ -1,11 +1,31 @@
 'use strict'
 
+// Maximum trace ID value is the maximum value for a 64-bit unsigned integer.
+// Javascript cannot handle such large numbers, we will loose precision but it's fine
+// as it is cast into a float64 when computing the threshold
+const MAX_TRACE_ID = 2 ** 64 - 1
+
+const UINT64_MODULO = 2n ** 64n
+
+// Knuth's factor for the sampling algorithm
+const SAMPLING_KNUTH_FACTOR = 1_111_111_111_111_111_111n
+
+/**
+ * `Sampler` determines whether or not to sample a trace/span based on the trace ID.
+ *
+ * This class uses a deterministic sampling algorithm that is consistent across all languages.
+ */
 class Sampler {
+  #threshold = 0n
+
   /**
-   * @param rate {number}
+   * @param {number} rate
    */
   constructor (rate) {
+    // TODO: Should this be moved up to the calling parts?
+    rate = Math.min(Math.max(rate, 0), 1)
     this._rate = rate
+    this.#threshold = BigInt(Math.floor(rate * MAX_TRACE_ID))
   }
 
   /**
@@ -15,11 +35,28 @@ class Sampler {
     return this._rate
   }
 
+  get threshold () {
+    return this.#threshold
+  }
+
   /**
-   * @returns {boolean}
+   * Determines whether a trace/span should be sampled based on the configured sampling rate.
+   *
+   * @param {Span|SpanContext} span - The span or span context to evaluate.
+   * @returns {boolean} `true` if the trace/span should be sampled, otherwise `false`.
    */
-  isSampled () {
-    return this._rate === 1 || Math.random() < this._rate
+  isSampled (span) {
+    if (this._rate === 1) {
+      return true
+    }
+
+    if (this._rate === 0) {
+      return false
+    }
+
+    span = typeof span.context === 'function' ? span.context() : span
+
+    return (span._traceId.toBigInt() * SAMPLING_KNUTH_FACTOR) % UINT64_MODULO <= this.#threshold
   }
 }
 

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

@@ -69,7 +69,7 @@ function resourceLocator (span) {
 }
 
 class SamplingRule {
-  constructor ({ name, service, resource, tags, sampleRate = 1.0, provenance = undefined, maxPerSecond } = {}) {
+  constructor ({ name, service, resource, tags, sampleRate = 1, provenance, maxPerSecond } = {}) {
     this.matchers = []
 
     if (name) {
@@ -112,6 +112,9 @@ class SamplingRule {
 
   match (span) {
     for (const matcher of this.matchers) {
+      // Rule is a special object with a .match() property.
+      // It has nothing to do with a regular expression.
+      // eslint-disable-next-line unicorn/prefer-regexp-test
       if (!matcher.match(span)) {
         return false
       }
@@ -120,8 +123,14 @@ class SamplingRule {
     return true
   }
 
-  sample () {
-    if (!this._sampler.isSampled()) {
+  /**
+   * Determines whether a span should be sampled based on the configured sampling rule.
+   *
+   * @param {Span|SpanContext} span - The span or span context to evaluate.
+   * @returns {boolean} `true` if the span should be sampled, otherwise `false`.
+   */
+  sample (span) {
+    if (!this._sampler.isSampled(span)) {
       return false
     }
 

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

@@ -52,7 +52,7 @@ class Scope {
   }
 
   _spanOrActive (span) {
-    return span !== undefined ? span : this.active()
+    return span === undefined ? this.active() : span
   }
 
   _isPromise (promise) {