dd-trace 4.45.0 → 4.47.0

package/packages/dd-trace/src/profiling/profilers/event_plugins/event.js

@@ -0,0 +1,48 @@
+const { AsyncLocalStorage } = require('async_hooks')
+const TracingPlugin = require('../../../plugins/tracing')
+const { performance } = require('perf_hooks')
+
+// We are leveraging the TracingPlugin class for its functionality to bind
+// start/error/finish methods to the appropriate diagnostic channels.
+class EventPlugin extends TracingPlugin {
+  constructor (eventHandler) {
+    super()
+    this.eventHandler = eventHandler
+    this.store = new AsyncLocalStorage()
+    this.entryType = this.constructor.entryType
+  }
+
+  start (startEvent) {
+    this.store.enterWith({
+      startEvent,
+      startTime: performance.now()
+    })
+  }
+
+  error () {
+    this.store.getStore().error = true
+  }
+
+  finish () {
+    const { startEvent, startTime, error } = this.store.getStore()
+    if (error) {
+      return // don't emit perf events for failed operations
+    }
+    const duration = performance.now() - startTime
+
+    const context = this.activeSpan?.context()
+    const _ddSpanId = context?.toSpanId()
+    const _ddRootSpanId = context?._trace.started[0]?.context().toSpanId() || _ddSpanId
+
+    const event = {
+      entryType: this.entryType,
+      startTime,
+      duration,
+      _ddSpanId,
+      _ddRootSpanId
+    }
+    this.eventHandler(this.extendEvent(event, startEvent))
+  }
+}
+
+module.exports = EventPlugin

package/packages/dd-trace/src/profiling/profilers/event_plugins/net.js

@@ -0,0 +1,24 @@
+const EventPlugin = require('./event')
+
+class NetPlugin extends EventPlugin {
+  static get id () {
+    return 'net'
+  }
+
+  static get operation () {
+    return 'tcp'
+  }
+
+  static get entryType () {
+    return 'net'
+  }
+
+  extendEvent (event, { options }) {
+    event.name = 'connect'
+    event.detail = options
+
+    return event
+  }
+}
+
+module.exports = NetPlugin

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

@@ -1,12 +1,8 @@
 const { performance, constants, PerformanceObserver } = require('perf_hooks')
-const { END_TIMESTAMP_LABEL } = require('./shared')
-const semver = require('semver')
+const { END_TIMESTAMP_LABEL, SPAN_ID_LABEL, LOCAL_ROOT_SPAN_ID_LABEL } = require('./shared')
 const { Function, Label, Line, Location, Profile, Sample, StringTable, ValueType } = require('pprof-format')
 const pprof = require('@datadog/pprof/')
 
-// Format of perf_hooks events changed with Node 16, we need to be mindful of it.
-const node16 = semver.gte(process.version, '16.0.0')
-
 // perf_hooks uses millis, with fractional part representing nanos. We emit nanos into the pprof file.
 const MS_TO_NS = 1000000
 
@@ -48,7 +44,7 @@ class GCDecorator {
   }
 
   decorateSample (sampleInput, item) {
-    const { kind, flags } = node16 ? item.detail : item
+    const { kind, flags } = item.detail
     sampleInput.label.push(this.kindLabels[kind])
     const reasonLabel = this.getReasonLabel(flags)
     if (reasonLabel) {
@@ -140,12 +136,9 @@ class NetDecorator {
 // Keys correspond to PerformanceEntry.entryType, values are constructor
 // functions for type-specific decorators.
 const decoratorTypes = {
-  gc: GCDecorator
-}
-// Needs at least node 16 for DNS and Net
-if (node16) {
-  decoratorTypes.dns = DNSDecorator
-  decoratorTypes.net = NetDecorator
+  gc: GCDecorator,
+  dns: DNSDecorator,
+  net: NetDecorator
 }
 
 // Translates performance entries into pprof samples.
@@ -168,10 +161,12 @@ class EventSerializer {
     this.locationId = [location.id]
 
     this.timestampLabelKey = this.stringTable.dedup(END_TIMESTAMP_LABEL)
+    this.spanIdKey = this.stringTable.dedup(SPAN_ID_LABEL)
+    this.rootSpanIdKey = this.stringTable.dedup(LOCAL_ROOT_SPAN_ID_LABEL)
   }
 
   addEvent (item) {
-    const { entryType, startTime, duration } = item
+    const { entryType, startTime, duration, _ddSpanId, _ddRootSpanId } = item
     let decorator = this.decorators[entryType]
     if (!decorator) {
       const DecoratorCtor = decoratorTypes[entryType]
@@ -186,13 +181,21 @@ class EventSerializer {
       }
     }
     const endTime = startTime + duration
+    const label = [
+      decorator.eventTypeLabel,
+      new Label({ key: this.timestampLabelKey, num: dateOffset + BigInt(Math.round(endTime * MS_TO_NS)) })
+    ]
+    if (_ddSpanId) {
+      label.push(labelFromStr(this.stringTable, this.spanIdKey, _ddSpanId))
+    }
+    if (_ddRootSpanId) {
+      label.push(labelFromStr(this.stringTable, this.rootSpanIdKey, _ddRootSpanId))
+    }
+
     const sampleInput = {
       value: [Math.round(duration * MS_TO_NS)],
       locationId: this.locationId,
-      label: [
-        decorator.eventTypeLabel,
-        new Label({ key: this.timestampLabelKey, num: dateOffset + BigInt(Math.round(endTime * MS_TO_NS)) })
-      ]
+      label
     }
     decorator.decorateSample(sampleInput, item)
     this.samples.push(new Sample(sampleInput))
@@ -219,36 +222,109 @@ class EventSerializer {
 }
 
 /**
- * This class generates pprof files with timeline events sourced from Node.js
- * performance measurement APIs.
+ * Class that sources timeline events through Node.js performance measurement APIs.
  */
-class EventsProfiler {
-  constructor (options = {}) {
-    this.type = 'events'
-    this._flushIntervalNanos = (options.flushInterval || 60000) * 1e6 // 60 sec
-    this._observer = undefined
-    this.eventSerializer = new EventSerializer()
+class NodeApiEventSource {
+  constructor (eventHandler, entryTypes) {
+    this.eventHandler = eventHandler
+    this.observer = undefined
+    this.entryTypes = entryTypes || Object.keys(decoratorTypes)
   }
 
   start () {
     // if already started, do nothing
-    if (this._observer) return
+    if (this.observer) return
 
     function add (items) {
       for (const item of items.getEntries()) {
-        this.eventSerializer.addEvent(item)
+        this.eventHandler(item)
       }
     }
-    this._observer = new PerformanceObserver(add.bind(this))
-    this._observer.observe({ entryTypes: Object.keys(decoratorTypes) })
+
+    this.observer = new PerformanceObserver(add.bind(this))
+    this.observer.observe({ entryTypes: this.entryTypes })
+  }
+
+  stop () {
+    if (this.observer) {
+      this.observer.disconnect()
+      this.observer = undefined
+    }
+  }
+}
+
+class DatadogInstrumentationEventSource {
+  constructor (eventHandler) {
+    this.plugins = ['dns_lookup', 'dns_lookupservice', 'dns_resolve', 'dns_reverse', 'net'].map(m => {
+      const Plugin = require(`./event_plugins/${m}`)
+      return new Plugin(eventHandler)
+    })
+
+    this.started = false
+  }
+
+  start () {
+    if (!this.started) {
+      this.plugins.forEach(p => p.configure({ enabled: true }))
+      this.started = true
+    }
   }
 
   stop () {
-    if (this._observer) {
-      this._observer.disconnect()
-      this._observer = undefined
+    if (this.started) {
+      this.plugins.forEach(p => p.configure({ enabled: false }))
+      this.started = false
     }
   }
+}
+
+class CompositeEventSource {
+  constructor (sources) {
+    this.sources = sources
+  }
+
+  start () {
+    this.sources.forEach(s => s.start())
+  }
+
+  stop () {
+    this.sources.forEach(s => s.stop())
+  }
+}
+
+/**
+ * This class generates pprof files with timeline events. It combines an event
+ * source with an event serializer.
+ */
+class EventsProfiler {
+  constructor (options = {}) {
+    this.type = 'events'
+    this.eventSerializer = new EventSerializer()
+
+    const eventHandler = event => {
+      this.eventSerializer.addEvent(event)
+    }
+
+    if (options.codeHotspotsEnabled) {
+      // Use Datadog instrumentation to collect events with span IDs. Still use
+      // Node API for GC events.
+      this.eventSource = new CompositeEventSource([
+        new DatadogInstrumentationEventSource(eventHandler),
+        new NodeApiEventSource(eventHandler, ['gc'])
+      ])
+    } else {
+      // Use Node API instrumentation to collect events without span IDs
+      this.eventSource = new NodeApiEventSource(eventHandler)
+    }
+  }
+
+  start () {
+    this.eventSource.start()
+  }
+
+  stop () {
+    this.eventSource.stop()
+  }
 
   profile (restart, startDate, endDate) {
     if (!restart) {

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

@@ -6,6 +6,9 @@ const END_TIMESTAMP_LABEL = 'end_timestamp_ns'
 const THREAD_NAME_LABEL = 'thread name'
 const OS_THREAD_ID_LABEL = 'os thread id'
 const THREAD_ID_LABEL = 'thread id'
+const SPAN_ID_LABEL = 'span id'
+const LOCAL_ROOT_SPAN_ID_LABEL = 'local root span id'
+
 const threadNamePrefix = isMainThread ? 'Main' : `Worker #${threadId}`
 const eventLoopThreadName = `${threadNamePrefix} Event Loop`
 
@@ -38,6 +41,8 @@ module.exports = {
   THREAD_NAME_LABEL,
   THREAD_ID_LABEL,
   OS_THREAD_ID_LABEL,
+  SPAN_ID_LABEL,
+  LOCAL_ROOT_SPAN_ID_LABEL,
   threadNamePrefix,
   eventLoopThreadName,
   getNonJSThreadsLabels,

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

@@ -7,7 +7,13 @@ const { HTTP_METHOD, HTTP_ROUTE, RESOURCE_NAME, SPAN_TYPE } = require('../../../
 const { WEB } = require('../../../../../ext/types')
 const runtimeMetrics = require('../../runtime_metrics')
 const telemetryMetrics = require('../../telemetry/metrics')
-const { END_TIMESTAMP_LABEL, getNonJSThreadsLabels, getThreadLabels } = require('./shared')
+const {
+  END_TIMESTAMP_LABEL,
+  SPAN_ID_LABEL,
+  LOCAL_ROOT_SPAN_ID_LABEL,
+  getNonJSThreadsLabels,
+  getThreadLabels
+} = require('./shared')
 
 const beforeCh = dc.channel('dd-trace:storage:before')
 const enterCh = dc.channel('dd-trace:storage:enter')
@@ -275,10 +281,10 @@ class NativeWallProfiler {
     }
 
     if (spanId) {
-      labels['span id'] = spanId
+      labels[SPAN_ID_LABEL] = spanId
     }
     if (rootSpanId) {
-      labels['local root span id'] = rootSpanId
+      labels[LOCAL_ROOT_SPAN_ID_LABEL] = rootSpanId
     }
     if (webTags && Object.keys(webTags).length !== 0) {
       labels['trace endpoint'] = endpointNameFromTags(webTags)

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

@@ -3,44 +3,11 @@
 const telemetryMetrics = require('../telemetry/metrics')
 const profilersNamespace = telemetryMetrics.manager.namespace('profilers')
 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 EnablementChoice = {
-  MANUALLY_ENABLED: Symbol('SSITelemetry.EnablementChoice.MANUALLY_ENABLED'),
-  SSI_ENABLED: Symbol('SSITelemetry.EnablementChoice.SSI_ENABLED'),
-  SSI_NOT_ENABLED: Symbol('SSITelemetry.EnablementChoice.SSI_NOT_ENABLED'),
-  DISABLED: Symbol('SSITelemetry.EnablementChoice.DISABLED')
-}
-Object.freeze(EnablementChoice)
-
-function getEnablementChoiceFromConfig (config) {
-  if (config.ssi === false || config.enabled === false) {
-    return EnablementChoice.DISABLED
-  } else if (config.heuristicsEnabled === true) {
-    return EnablementChoice.SSI_ENABLED
-  } else if (config.enabled === true) {
-    return EnablementChoice.MANUALLY_ENABLED
-  } else {
-    return EnablementChoice.SSI_NOT_ENABLED
-  }
-}
-
-function enablementChoiceToTagValue (enablementChoice) {
-  switch (enablementChoice) {
-    case EnablementChoice.MANUALLY_ENABLED:
-      return 'manually_enabled'
-    case EnablementChoice.SSI_ENABLED:
-      return 'ssi_enabled'
-    case EnablementChoice.SSI_NOT_ENABLED:
-      return 'not_enabled'
-    case EnablementChoice.DISABLED:
-      // Can't emit this one as a tag
-      throw new Error('Invalid enablement choice')
-  }
-}
-
 /**
  * This class embodies the SSI profiler-triggering heuristics and also emits telemetry metrics about
  * the profiler behavior under SSI. It emits the following metrics:
@@ -56,25 +23,48 @@ function enablementChoiceToTagValue (enablementChoice) {
  */
 class SSIHeuristics {
   constructor (config) {
-    this.enablementChoice = getEnablementChoiceFromConfig(config)
+    const injectionIncludesProfiler = config.injectionEnabled.includes('profiler')
+    this._heuristicsActive = injectionIncludesProfiler || config.profiling.enabled === 'auto'
+    this._emitsTelemetry = config.injectionEnabled.length > 0 && config.profiling.enabled !== 'false'
+
+    if (this._emitsTelemetry) {
+      if (config.profiling.enabled === 'true') {
+        this.enablementChoice = 'manually_enabled'
+      } else if (injectionIncludesProfiler) {
+        this.enablementChoice = 'ssi_enabled'
+      } else if (config.profiling.enabled === 'auto') {
+        this.enablementChoice = 'auto_enabled'
+      } else {
+        this.enablementChoice = 'ssi_not_enabled'
+      }
+    }
 
-    const longLivedThreshold = config.longLivedThreshold || DEFAULT_LONG_LIVED_THRESHOLD
+    const longLivedThreshold = config.profiling.longLivedThreshold || DEFAULT_LONG_LIVED_THRESHOLD
     if (typeof longLivedThreshold !== 'number' || longLivedThreshold <= 0) {
-      throw new Error('Long-lived threshold must be a positive number')
+      this.longLivedThreshold = DEFAULT_LONG_LIVED_THRESHOLD
+      log.warn(
+        `Invalid SSIHeuristics.longLivedThreshold value: ${config.profiling.longLivedThreshold}. ` +
+        `Using default value: ${DEFAULT_LONG_LIVED_THRESHOLD}`
+      )
+    } else {
+      this.longLivedThreshold = longLivedThreshold
     }
-    this.longLivedThreshold = longLivedThreshold
 
     this.hasSentProfiles = false
     this.noSpan = true
     this.shortLived = true
   }
 
-  enabled () {
-    return this.enablementChoice !== EnablementChoice.DISABLED
+  get emitsTelemetry () {
+    return this._emitsTelemetry
+  }
+
+  get heuristicsActive () {
+    return this._heuristicsActive
   }
 
   start () {
-    if (this.enabled()) {
+    if (this.heuristicsActive || this.emitsTelemetry) {
       // Used to determine short-livedness of the process. We could use the process start time as the
       // reference point, but the tracer initialization point is more relevant, as we couldn't be
       // collecting profiles earlier anyway. The difference is not particularly significant if the
@@ -85,13 +75,17 @@ class SSIHeuristics {
       }, this.longLivedThreshold).unref()
 
       this._onSpanCreated = this._onSpanCreated.bind(this)
-      this._onProfileSubmitted = this._onProfileSubmitted.bind(this)
-      this._onMockProfileSubmitted = this._onMockProfileSubmitted.bind(this)
-      this._onAppClosing = this._onAppClosing.bind(this)
-
       dc.subscribe('dd-trace:span:start', this._onSpanCreated)
-      dc.subscribe('datadog:profiling:profile-submitted', this._onProfileSubmitted)
-      dc.subscribe('datadog:profiling:mock-profile-submitted', this._onMockProfileSubmitted)
+
+      if (this.emitsTelemetry) {
+        this._onProfileSubmitted = this._onProfileSubmitted.bind(this)
+        this._onMockProfileSubmitted = this._onMockProfileSubmitted.bind(this)
+
+        dc.subscribe('datadog:profiling:profile-submitted', this._onProfileSubmitted)
+        dc.subscribe('datadog:profiling:mock-profile-submitted', this._onMockProfileSubmitted)
+      }
+
+      this._onAppClosing = this._onAppClosing.bind(this)
       dc.subscribe('datadog:telemetry:app-closing', this._onAppClosing)
     }
   }
@@ -106,6 +100,8 @@ class SSIHeuristics {
         })
         break
       default:
+        // injection hardening: only usage is internal, one call site with
+        // a function and another with undefined, so we can throw here.
         throw new TypeError('callback must be a function or undefined')
     }
   }
@@ -152,7 +148,7 @@ class SSIHeuristics {
 
     const tags = [
       'installation:ssi',
-      `enablement_choice:${enablementChoiceToTagValue(this.enablementChoice)}`,
+      `enablement_choice:${this.enablementChoice}`,
       `has_sent_profiles:${this.hasSentProfiles}`,
       `heuristic_hypothetical_decision:${decision.join('_')}`
     ]
@@ -163,9 +159,9 @@ class SSIHeuristics {
     if (
       !this._emittedRuntimeId &&
       decision[0] === 'triggered' &&
-      // When enablement choice is SSI_ENABLED, hasSentProfiles can transition from false to true when the
+      // When heuristics are active, hasSentProfiles can transition from false to true when the
       // profiler gets started and the first profile is submitted, so we have to wait for it.
-      (this.enablementChoice !== EnablementChoice.SSI_ENABLED || this.hasSentProfiles)
+      (!this.heuristicsActive || this.hasSentProfiles)
     ) {
       // Tags won't change anymore, so we can emit the runtime ID metric now.
       this._emittedRuntimeId = true
@@ -174,17 +170,20 @@ class SSIHeuristics {
   }
 
   _onAppClosing () {
-    this._ensureProfileMetrics()
-    // Last ditch effort to emit a runtime ID count metric
-    if (!this._emittedRuntimeId) {
-      this._emittedRuntimeId = true
-      this._runtimeIdCount.inc()
+    if (this.emitsTelemetry) {
+      this._ensureProfileMetrics()
+      // Last ditch effort to emit a runtime ID count metric
+      if (!this._emittedRuntimeId) {
+        this._emittedRuntimeId = true
+        this._runtimeIdCount.inc()
+      }
+      // So we have the metrics in the final state
+      this._profileCount.inc(0)
+
+      dc.unsubscribe('datadog:profiling:profile-submitted', this._onProfileSubmitted)
+      dc.unsubscribe('datadog:profiling:mock-profile-submitted', this._onMockProfileSubmitted)
     }
-    // So we have the metrics in the final state
-    this._profileCount.inc(0)
 
-    dc.unsubscribe('datadog:profiling:profile-submitted', this._onProfileSubmitted)
-    dc.unsubscribe('datadog:profiling:mock-profile-submitted', this._onMockProfileSubmitted)
     dc.unsubscribe('datadog:telemetry:app-closing', this._onAppClosing)
     if (this.noSpan) {
       dc.unsubscribe('dd-trace:span:start', this._onSpanCreated)
@@ -192,4 +191,4 @@ class SSIHeuristics {
   }
 }
 
-module.exports = { SSIHeuristics, EnablementChoice }
+module.exports = { SSIHeuristics }

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

@@ -5,6 +5,7 @@ const Config = require('./config')
 const runtimeMetrics = require('./runtime_metrics')
 const log = require('./log')
 const { setStartupLogPluginManager } = require('./startup-log')
+const DynamicInstrumentation = require('./debugger')
 const telemetry = require('./telemetry')
 const nomenclature = require('./service-naming')
 const PluginManager = require('./plugin_manager')
@@ -14,7 +15,6 @@ const dogstatsd = require('./dogstatsd')
 const NoopDogStatsDClient = require('./noop/dogstatsd')
 const spanleak = require('./spanleak')
 const { SSIHeuristics } = require('./profiling/ssi-heuristics')
-const telemetryLog = require('dc-polyfill').channel('datadog:telemetry:log')
 const appsecStandalone = require('./appsec/standalone')
 
 class LazyModule {
@@ -84,7 +84,7 @@ class Tracer extends NoopProxy {
       if (config.remoteConfig.enabled && !config.isCiVisibility) {
         const rc = remoteConfig.enable(config, this._modules.appsec)
 
-        rc.on('APM_TRACING', (action, conf) => {
+        rc.setProductHandler('APM_TRACING', (action, conf) => {
           if (action === 'unapply') {
             config.configure({}, true)
           } else {
@@ -93,7 +93,7 @@ class Tracer extends NoopProxy {
           this._enableOrDisableTracing(config)
         })
 
-        rc.on('AGENT_CONFIG', (action, conf) => {
+        rc.setProductHandler('AGENT_CONFIG', (action, conf) => {
           if (!conf?.name?.startsWith('flare-log-level.')) return
 
           if (action === 'unapply') {
@@ -104,37 +104,49 @@ class Tracer extends NoopProxy {
           }
         })
 
-        rc.on('AGENT_TASK', (action, conf) => {
+        rc.setProductHandler('AGENT_TASK', (action, conf) => {
           if (action === 'unapply' || !conf) return
           if (conf.task_type !== 'tracer_flare' || !conf.args) return
 
           this._flare.enable(config)
           this._flare.module.send(conf.args)
         })
+
+        if (config.dynamicInstrumentationEnabled) {
+          DynamicInstrumentation.start(config, rc)
+        }
       }
 
       if (config.isGCPFunction || config.isAzureFunction) {
         require('./serverless').maybeStartServerlessMiniAgent(config)
       }
 
-      const ssiHeuristics = new SSIHeuristics(config.profiling)
-      ssiHeuristics.start()
-      if (config.profiling.enabled) {
-        this._profilerStarted = this._startProfiler(config)
-      } else if (config.profiling.ssi) {
-        const mockProfiler = require('./profiling/ssi-telemetry-mock-profiler')
-        mockProfiler.start(config)
+      if (config.profiling.enabled !== 'false') {
+        const ssiHeuristics = new SSIHeuristics(config)
+        ssiHeuristics.start()
+        let mockProfiler = null
+        if (config.profiling.enabled === 'true') {
+          this._profilerStarted = this._startProfiler(config)
+        } else if (ssiHeuristics.emitsTelemetry) {
+          // Start a mock profiler that emits mock profile-submitted events for the telemetry.
+          // It will be stopped if the real profiler is started by the heuristics.
+          mockProfiler = require('./profiling/ssi-telemetry-mock-profiler')
+          mockProfiler.start(config)
+        }
 
-        if (config.profiling.heuristicsEnabled) {
+        if (ssiHeuristics.heuristicsActive) {
           ssiHeuristics.onTriggered(() => {
-            mockProfiler.stop()
+            if (mockProfiler) {
+              mockProfiler.stop()
+            }
             this._startProfiler(config)
-            ssiHeuristics.onTriggered()
+            ssiHeuristics.onTriggered() // deregister this callback
           })
         }
-      }
-      if (!this._profilerStarted) {
-        this._profilerStarted = Promise.resolve(false)
+
+        if (!this._profilerStarted) {
+          this._profilerStarted = Promise.resolve(false)
+        }
       }
 
       if (config.runtimeMetrics) {
@@ -163,13 +175,6 @@ class Tracer extends NoopProxy {
       return require('./profiler').start(config)
     } catch (e) {
       log.error(e)
-      if (telemetryLog.hasSubscribers) {
-        telemetryLog.publish({
-          message: e.message,
-          level: 'ERROR',
-          stack_trace: e.stack
-        })
-      }
     }
   }
 
@@ -196,12 +201,14 @@ class Tracer extends NoopProxy {
     if (this._tracingInitialized) {
       this._tracer.configure(config)
       this._pluginManager.configure(config)
+      DynamicInstrumentation.configure(config)
       setStartupLogPluginManager(this._pluginManager)
     }
   }
 
   profilerStarted () {
     if (!this._profilerStarted) {
+      // injection hardening: this is only ever invoked from tests.
       throw new Error('profilerStarted() must be called after init()')
     }
     return this._profilerStarted

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

@@ -127,7 +127,8 @@ class SpanStatsProcessor {
     url,
     env,
     tags,
-    appsec
+    appsec,
+    version
   } = {}) {
     this.exporter = new SpanStatsExporter({
       hostname,
@@ -143,6 +144,7 @@ class SpanStatsProcessor {
     this.env = env
     this.tags = tags || {}
     this.sequence = 0
+    this.version = version
 
     if (this.enabled) {
       this.timer = setInterval(this.onInterval.bind(this), interval * 1e3)
@@ -157,7 +159,7 @@ class SpanStatsProcessor {
     this.exporter.export({
       Hostname: this.hostname,
       Env: this.env,
-      Version: version,
+      Version: this.version || version,
       Stats: serialized,
       Lang: 'javascript',
       TracerVersion: pkg.version,