dd-trace 6.15.0 → 6.17.0

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

@@ -61,9 +61,12 @@ class Profiler extends EventEmitter {
   #exporters
   #flushInterval
   #lastStart
+  #pendingStart
   #profileSeq = 0
   #profilers
   #spanFinishListener
+  #startFailed = false
+  #stopping
   #systemInfoReport
   #currentSnapshotTags
   #timer
@@ -175,48 +178,72 @@ class Profiler extends EventEmitter {
    */
   start (config) {
     if (this.enabled) return true
-    this.#enabled = true
-
-    const { tags: snapshotTags, exporters, flushInterval, profilers, uploadCompression, systemInfoReport } =
-      buildProfilingRuntime(config)
-    this.#config = config
-    this.#exporters = exporters
-    this.#flushInterval = flushInterval
-    this.#profilers = profilers
-    this.#currentSnapshotTags = snapshotTags
-    this.#uploadCompression = uploadCompression
-    this.#systemInfoReport = systemInfoReport
-    if (this.#customLabelKeys.size > 0) {
-      this.#applyCustomLabelKeys()
-    }
-
-    this._setInterval()
-    // Log errors if the source map finder fails, but don't prevent the rest
-    // of the profiler from running without source maps.
-    let mapper
-    const { setLogger, SourceMapper } = require('@datadog/pprof')
-    setLogger(pprofLogger)
-
-    if (config.DD_PROFILING_SOURCE_MAP) {
-      mapper = new SourceMapper(config.DD_PROFILING_DEBUG_SOURCE_MAPS)
-      mapper.loadDirectory(process.cwd())
-        .then(() => {
-          if (config.DD_PROFILING_DEBUG_SOURCE_MAPS) {
-            const count = mapper.infoMap.size
-            // eslint-disable-next-line eslint-rules/eslint-log-printf-style
-            log.debug(() => {
-              return count === 0
-                ? 'Found no source maps'
-                : `Found source maps for following files: [${[...mapper.infoMap.keys()].join(', ')}]`
-            })
-          }
-        })
-        .catch((error) => {
-          log.error(error)
-        })
+    // Initialization failures such as an unavailable native pprof binding are not expected to
+    // recover within the lifetime of this process. Preserve that decision without pretending the
+    // profiler is running or retrying setup on every subsequent config publication.
+    if (this.#startFailed) return false
+
+    // A prior stop()'s shutdown collection may still be encoding/exporting via #tags,
+    // #exporters and #endpointCounts. Wait for it to finish before this start() overwrites
+    // that shared state out from under it. Record the desired config rather than chaining
+    // straight onto #stopping, so a stop() arriving before it settles can cancel this restart.
+    if (this.#stopping) {
+      this.#pendingStart = config
+      return true
     }
 
     try {
+      const { tags: snapshotTags, exporters, flushInterval, profilers, uploadCompression, systemInfoReport } =
+        buildProfilingRuntime(config)
+      this.#config = config
+      this.#exporters = exporters
+      this.#flushInterval = flushInterval
+      this.#profilers = profilers
+      this.#currentSnapshotTags = snapshotTags
+      // A restart is installed only after the prior shutdown collection settles, so any endpoint
+      // counts left behind by a collection that produced no encodable profiles belong to the old run.
+      this.#endpointCounts.clear()
+      // Compression is initialized lazily and cached for a profiling run. A restarted profiler
+      // must derive it again from the newly built runtime instead of retaining the prior method
+      // or options.
+      this.#compressionFn = undefined
+      this.#compressionFnInitialized = false
+      this.#compressionOptions = undefined
+      this.#uploadCompression = uploadCompression
+      this.#systemInfoReport = systemInfoReport
+      if (this.#customLabelKeys.size > 0) {
+        this.#applyCustomLabelKeys()
+      }
+
+      this._setInterval()
+      // Log errors if the source map finder fails, but don't prevent the rest
+      // of the profiler from running without source maps.
+      let mapper
+      const { setLogger, SourceMapper } = require('@datadog/pprof')
+      setLogger(pprofLogger)
+
+      if (config.DD_PROFILING_SOURCE_MAP) {
+        mapper = new SourceMapper(config.DD_PROFILING_DEBUG_SOURCE_MAPS)
+        mapper.loadDirectory(process.cwd())
+          .then(() => {
+            if (config.DD_PROFILING_DEBUG_SOURCE_MAPS) {
+              const count = mapper.infoMap.size
+              // eslint-disable-next-line eslint-rules/eslint-log-printf-style
+              log.debug(() => {
+                return count === 0
+                  ? 'Found no source maps'
+                  : `Found source maps for following files: [${[...mapper.infoMap.keys()].join(', ')}]`
+              })
+            }
+          })
+          .catch((error) => {
+            log.error(error)
+          })
+      }
+
+      // Setup above does not start any sampler runtime resources. From this point onward, #stop()
+      // can safely clean up a partial start because #profilers and the rest of the runtime exist.
+      this.#enabled = true
       const start = new Date()
       const nearOOMCallback = this.#nearOOMExport.bind(this)
       for (const profiler of profilers) {
@@ -236,7 +263,17 @@ class Profiler extends EventEmitter {
       this._capture(this._timeoutInterval, start)
     } catch (error) {
       log.error(error)
-      this.#stop()
+      this.#startFailed = true
+      if (this.enabled) {
+        try {
+          this.#stop()
+        } catch (stopError) {
+          // A cleanup failure must not leave the public running state stuck at true or escape into
+          // the customer application.
+          this.#enabled = false
+          log.error(stopError)
+        }
+      }
       return false
     }
 
@@ -258,11 +295,34 @@ class Profiler extends EventEmitter {
   }
 
   stop () {
+    // A stop() always reflects the latest desired state, so it cancels any restart queued by a
+    // start() that arrived while a prior shutdown collection was still in flight.
+    this.#pendingStart = undefined
+
     if (!this.enabled) return
 
     // collect and export current profiles
     // once collect returns, profilers can be safely stopped
-    this._collect(snapshotKinds.ON_SHUTDOWN, false)
+    this.#stopping = this._collect(snapshotKinds.ON_SHUTDOWN, false)
+      .catch(error => {
+        // _collect() contains its own failures, but its cleanup can still throw. Nothing awaits
+        // this shutdown chain, so consume and log that failure instead of leaking a rejection.
+        log.error(error)
+      })
+      .finally(() => {
+        this.#stopping = undefined
+        if (this.#pendingStart) {
+          const config = this.#pendingStart
+          this.#pendingStart = undefined
+          // Unlike the synchronous entry point, nothing awaits this promise, so a throw here would
+          // become an unhandled rejection instead of a caught error.
+          try {
+            this.start(config)
+          } catch (error) {
+            log.error(error)
+          }
+        }
+      })
     this.#stop()
   }
 

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

@@ -10,6 +10,11 @@ const DEFAULT_LONG_LIVED_THRESHOLD = 30_000
  * This class embodies the SSI profiler-triggering heuristics under SSI.
  */
 class SSIHeuristics {
+  #active = false
+  #longLivedTimer
+  #onAppClosing = this.disable.bind(this)
+  #onSpanCreated = this.#handleSpanCreated.bind(this)
+
   /**
    * @param {import('../config/config-base')} config - Tracer configuration
    */
@@ -32,20 +37,36 @@ class SSIHeuristics {
   }
 
   start () {
+    if (this.#active) return
+    this.#active = true
+
     // 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
     // tracer is initialized early in the process lifetime.
-    setTimeout(() => {
+    this.#longLivedTimer = setTimeout(() => {
+      this.#longLivedTimer = undefined
       this.shortLived = false
       this._maybeTriggered()
-    }, this.longLivedThreshold).unref?.()
+    }, this.longLivedThreshold)
+    this.#longLivedTimer.unref?.()
 
-    this._onSpanCreated = this._onSpanCreated.bind(this)
-    dc.subscribe('dd-trace:span:start', this._onSpanCreated)
+    dc.subscribe('dd-trace:span:start', this.#onSpanCreated)
+    dc.subscribe('datadog:telemetry:app-closing', this.#onAppClosing)
+  }
 
-    this._onAppClosing = this._onAppClosing.bind(this)
-    dc.subscribe('datadog:telemetry:app-closing', this._onAppClosing)
+  /**
+   * Cancels the pending heuristic and releases all resources owned by this instance.
+   */
+  disable () {
+    this.triggeredCallback = undefined
+    if (!this.#active) return
+
+    this.#active = false
+    clearTimeout(this.#longLivedTimer)
+    this.#longLivedTimer = undefined
+    dc.unsubscribe('dd-trace:span:start', this.#onSpanCreated)
+    dc.unsubscribe('datadog:telemetry:app-closing', this.#onAppClosing)
   }
 
   onTriggered (callback) {
@@ -70,17 +91,10 @@ class SSIHeuristics {
     }
   }
 
-  _onSpanCreated () {
+  #handleSpanCreated () {
     this.noSpan = false
     this._maybeTriggered()
-    dc.unsubscribe('dd-trace:span:start', this._onSpanCreated)
-  }
-
-  _onAppClosing () {
-    dc.unsubscribe('datadog:telemetry:app-closing', this._onAppClosing)
-    if (this.noSpan) {
-      dc.unsubscribe('dd-trace:span:start', this._onSpanCreated)
-    }
+    dc.unsubscribe('dd-trace:span:start', this.#onSpanCreated)
   }
 }
 

package/packages/dd-trace/src/propagation-hash/index.js

@@ -30,7 +30,6 @@ class PropagationHashManager {
 
   /**
    * Check if process tags propagation is enabled
-   * @returns {boolean}
    */
   isEnabled () {
     return this._config?.DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED === true

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

@@ -49,6 +49,10 @@ const OPENFEATURE_STATE_NOOP = 0
 const OPENFEATURE_STATE_LAZY = 1
 const OPENFEATURE_STATE_ACTIVE = 2
 
+const configUpdateChannel = channel('datadog:config:update')
+
+const profiler = require('./profiler')
+
 let dynamicInstrumentation
 
 function getDynamicInstrumentation () {
@@ -114,6 +118,9 @@ function defineLazily (obj, property, getClass, ...args) {
 class Tracer extends NoopProxy {
   #openfeatureState = OPENFEATURE_STATE_NOOP
 
+  /** @type {boolean} */
+  #configPublished = false
+
   constructor () {
     super()
 
@@ -249,20 +256,8 @@ class Tracer extends NoopProxy {
         openfeatureRemoteConfig.enable(rc, () => this.openfeature, subscribeOpenfeatureToRemoteConfig)
       }
 
-      if (config.profiling.DD_PROFILING_ENABLED === 'true') {
-        this._profilerStarted = this._startProfiler(config)
-      } else {
-        this._profilerStarted = false
-        if (config.profiling.DD_PROFILING_ENABLED === 'auto') {
-          const { SSIHeuristics } = require('./profiling/ssi-heuristics')
-          const ssiHeuristics = new SSIHeuristics(config)
-          ssiHeuristics.start()
-          ssiHeuristics.onTriggered(() => {
-            this._startProfiler(config)
-            ssiHeuristics.onTriggered() // deregister this callback
-          })
-        }
-      }
+      configUpdateChannel.publish(config)
+      this.#configPublished = true
 
       // Experimental: mirror the active trace ID, span ID and endpoint into
       // an OTEP-4947 thread-local context record an out-of-process eBPF
@@ -297,7 +292,7 @@ class Tracer extends NoopProxy {
 
       this.#updateTracing(config)
 
-      if (config.iast.enabled) {
+      if (config.iast.DD_IAST_ENABLED) {
         this._modules.rewriter.enable(config)
       }
 
@@ -373,22 +368,6 @@ class Tracer extends NoopProxy {
     ch.subscribe(onHttpRequest)
   }
 
-  /**
-   * @param {import('./config/config-base')} config - Tracer configuration
-   */
-  _startProfiler (config) {
-    // do not stop tracer initialization if the profiler fails to be imported
-    try {
-      return require('./profiler').start(config)
-    } catch (error) {
-      log.error(
-        'Error starting profiler. For troubleshooting tips, see <https://dtdg.co/nodejs-profiler-troubleshooting>',
-        error
-      )
-      return false
-    }
-  }
-
   /**
    * `tracer.openfeature` is only reachable through this proxy. SSI itself (auto-injecting
    * the tracer, resolving the vendored provider regardless of the customer's own
@@ -428,7 +407,7 @@ class Tracer extends NoopProxy {
    */
   #updateTracing (config) {
     if (config.DD_TRACE_ENABLED !== false) {
-      if (config.appsec.enabled) {
+      if (config.appsec.DD_APPSEC_ENABLED) {
         this._modules.appsec.enable(config)
       }
       if (config.llmobs.DD_LLMOBS_ENABLED) {
@@ -441,17 +420,18 @@ class Tracer extends NoopProxy {
         this._tracer = new DatadogTracer(config, prioritySampler)
         this.dataStreamsCheckpointer = this._tracer.dataStreamsCheckpointer
         lazyProxy(this, 'appsec', () => require('./appsec/sdk'), this._tracer, config)
-        lazyProxy(this, 'llmobs', () => require('./llmobs/sdk'), this._tracer, this._modules.llmobs, config)
+        lazyProxy(this, 'llmobs', () => require('./llmobs/sdk'), this._tracer, this._modules.llmobs, config,
+          () => this.openfeature)
 
-        if (config.experimental?.aiguard?.enabled) {
+        if (config.aiguard.DD_AI_GUARD_ENABLED) {
           lazyProxy(this, 'aiguard', () => require('./aiguard/sdk'), this._tracer, config)
         }
         this._tracingInitialized = true
       }
-      if (config.experimental?.aiguard?.enabled) {
+      if (config.aiguard.DD_AI_GUARD_ENABLED) {
         this._modules.aiguard.enable(this._tracer, config)
       }
-      if (config.iast.enabled) {
+      if (config.iast.DD_IAST_ENABLED) {
         this._modules.iast.enable(config, this._tracer)
       }
       // This needs to be after the IAST module is enabled
@@ -507,15 +487,13 @@ class Tracer extends NoopProxy {
    * @override
    */
   get profiling () {
-    // Lazily require the profiler module and cache the result. If profiling
-    // is not enabled, runWithLabels still works as a passthrough (just calls fn()).
-    const profilerModule = require('./profiler')
+    // If profiling is not enabled, runWithLabels still works as a passthrough (just calls fn()).
     const profiling = {
       setCustomLabelKeys (keys) {
-        profilerModule.setCustomLabelKeys(keys)
+        profiler.setCustomLabelKeys(keys)
       },
       runWithLabels (labels, fn) {
-        return profilerModule.runWithLabels(labels, fn)
+        return profiler.runWithLabels(labels, fn)
       },
     }
     Reflect.defineProperty(this, 'profiling', { value: profiling, configurable: true, enumerable: true })
@@ -526,11 +504,11 @@ class Tracer extends NoopProxy {
    * @override
    */
   profilerStarted () {
-    if (this._profilerStarted === undefined) {
+    if (!this.#configPublished) {
       // injection hardening: this is only ever invoked from tests.
       throw new Error('profilerStarted() must be called after init()')
     }
-    return Promise.resolve(this._profilerStarted)
+    return Promise.resolve(profiler.isStarted())
   }
 
   /**
@@ -552,7 +530,6 @@ class Tracer extends NoopProxy {
 /**
  * Checks the private filesystem-only Test Optimization validation mode.
  *
- * @returns {boolean} whether network-capable tracer side channels must stay disabled
  */
 function isOfflineTestOptimizationValidation () {
   return isTrue(getEnvironmentVariable(VALIDATION_MODE_ENV)) &&
@@ -564,7 +541,6 @@ function isOfflineTestOptimizationValidation () {
  * Checks whether initialization selected a filesystem-only Test Optimization exporter.
  *
  * @param {import('../../../index').TracerOptions} [options] tracer initialization options
- * @returns {boolean} whether the selected exporter is safe for offline validation
  */
 function isOfflineValidationExporter (options) {
   return OFFLINE_VALIDATION_EXPORTERS.has(options?.experimental?.exporter)

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

@@ -17,9 +17,6 @@ class RandomSampler {
     this._rate = rate
   }
 
-  /**
-   * @returns {number}
-   */
   rate () {
     return this._rate
   }
@@ -30,7 +27,6 @@ class RandomSampler {
    * 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

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

@@ -21,7 +21,6 @@ class RateLimiter {
    * Attempts to consume a token and reports whether it was allowed.
    * Updates internal counters used for effective rate computation.
    *
-   * @returns {boolean}
    */
   isAllowed () {
     const curIntervalStart = this._limiter.curIntervalStart
@@ -43,7 +42,6 @@ class RateLimiter {
    * Returns the fraction of allowed requests over requested ones in the
    * current and previous intervals combined.
    *
-   * @returns {number}
    */
   effectiveRate () {
     if (this._rateLimit < 0) return 1
@@ -58,7 +56,6 @@ class RateLimiter {
 
   /**
    * Internal token consumption without counter side-effects.
-   * @returns {boolean}
    */
   _isAllowed () {
     if (this._rateLimit < 0) return true
@@ -69,7 +66,6 @@ class RateLimiter {
 
   /**
    * Effective rate within the current interval only.
-   * @returns {number}
    */
   _currentWindowRate () {
     if (this._rateLimit < 0) return 1

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

@@ -12,33 +12,25 @@ module.exports = {
   ASM_CUSTOM_BLOCKING_RESPONSE: 1n << 9n,
   ASM_TRUSTED_IPS: 1n << 10n,
   ASM_API_SECURITY_SAMPLE_RATE: 1n << 11n, // deprecated
-  APM_TRACING_SAMPLE_RATE: 1n << 12n,
-  APM_TRACING_LOGS_INJECTION: 1n << 13n,
-  APM_TRACING_HTTP_HEADER_TAGS: 1n << 14n,
-  APM_TRACING_CUSTOM_TAGS: 1n << 15n,
   ASM_PROCESSOR_OVERRIDES: 1n << 16n,
   ASM_CUSTOM_DATA_SCANNERS: 1n << 17n,
   ASM_EXCLUSION_DATA: 1n << 18n,
-  APM_TRACING_ENABLED: 1n << 19n,
   ASM_RASP_SQLI: 1n << 21n,
   ASM_RASP_LFI: 1n << 22n,
   ASM_RASP_SSRF: 1n << 23n,
   ASM_RASP_SHI: 1n << 24n,
-  APM_TRACING_SAMPLE_RULES: 1n << 29n,
   ASM_AUTO_USER_INSTRUM_MODE: 1n << 31n,
   ASM_ENDPOINT_FINGERPRINT: 1n << 32n,
   ASM_SESSION_FINGERPRINT: 1n << 33n,
   ASM_NETWORK_FINGERPRINT: 1n << 34n,
   ASM_HEADER_FINGERPRINT: 1n << 35n,
   ASM_RASP_CMDI: 1n << 37n,
-  APM_TRACING_ENABLE_DYNAMIC_INSTRUMENTATION: 1n << 38n,
-  APM_TRACING_ENABLE_CODE_ORIGIN: 1n << 40n,
-  APM_TRACING_ENABLE_LIVE_DEBUGGING: 1n << 41n,
   ASM_DD_MULTICONFIG: 1n << 42n,
   ASM_TRACE_TAGGING_RULES: 1n << 43n,
   ASM_EXTENDED_DATA_COLLECTION: 1n << 44n,
   APM_TRACING_MULTICONFIG: 1n << 45n,
   FFE_FLAG_CONFIGURATION_RULES: 1n << 46n,
+  SDK_CONFIGURATION: 1n << 49n,
   /*
     DO NOT ADD ARBITRARY CAPABILITIES IN YOUR CODE
     UNLESS THEY ARE ALREADY DEFINED IN THE BACKEND SOURCE OF TRUTH

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

@@ -234,7 +234,6 @@ class RemoteConfig {
   /**
    * Updates the native client with the current products and capabilities.
    *
-   * @returns {void}
    */
   #updateProductCapabilities () {
     const fetcher = this.#fetcher

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

@@ -195,9 +195,6 @@ module.exports = {
     log.debug('Started OTLP runtime metrics with OTel-native naming (v8js.*, nodejs.*)')
   },
 
-  /**
-   * @returns {void}
-   */
   stop () {
     if (eventLoopHistogram) {
       eventLoopHistogram.disable()

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

@@ -28,9 +28,6 @@ class Sampler {
     this.#threshold = BigInt(Math.floor(rate * MAX_TRACE_ID))
   }
 
-  /**
-   * @returns {number}
-   */
   rate () {
     return this._rate
   }
@@ -43,7 +40,6 @@ class Sampler {
    * Determines whether a trace/span should be sampled based on the configured sampling rate.
    *
    * @param {import("../../..").Span|import("../../..").SpanContext} span - The span or span context to evaluate.
-   * @returns {boolean} `true` if the trace/span should be sampled, otherwise `false`.
    */
   isSampled (span) {
     if (this._rate === 1) {

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

@@ -27,7 +27,6 @@ const Sampler = require('./sampler')
 class AlwaysMatcher {
   /**
    * @param {DatadogSpan} span
-   * @returns {boolean}
    */
   match (span) {
     return true
@@ -42,7 +41,6 @@ class AlwaysMatcher {
 class NeverMatcher {
   /**
    * @param {DatadogSpan} span
-   * @returns {boolean}
    */
   match (span) {
     return false
@@ -64,7 +62,6 @@ class GlobMatcher {
 
   /**
    * @param {DatadogSpan} span
-   * @returns {boolean}
    */
   match (span) {
     const subject = this.locator(span)
@@ -91,7 +88,6 @@ class RegExpMatcher {
 
   /**
    * @param {DatadogSpan} span
-   * @returns {boolean}
    */
   match (span) {
     const subject = this.locator(span)
@@ -235,7 +231,6 @@ class SamplingRule {
 
   /**
    * Deterministic sampling rate in [0, 1].
-   * @returns {number}
    */
   get sampleRate () {
     return this._sampler.rate()
@@ -261,7 +256,6 @@ class SamplingRule {
    * Checks whether the provided span matches all configured criteria.
    *
    * @param {DatadogSpan} span
-   * @returns {boolean}
    */
   match (span) {
     for (const matcher of this.matchers) {
@@ -280,7 +274,6 @@ class SamplingRule {
    * Determines whether a span should be sampled based on the configured sampling rule.
    *
    * @param {DatadogSpan|DatadogSpanContext} 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)) {

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

@@ -32,7 +32,6 @@ function createVercelFlush () {
 /**
  * @param {TelemetryFlusher} tracer
  * @param {() => void} done
- * @returns {void}
  */
 function flushVercelTelemetry (tracer, done) {
   setImmediate(() => {

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

@@ -69,7 +69,6 @@ function getServerlessPlatform () {
  * Whether the current platform can retain an invocation for telemetry delivery.
  *
  * Add future serverless platforms here as they gain an equivalent retention hook.
- * @returns {boolean}
  */
 function supportsServerlessTelemetryRetention () {
   return isVercelAtStartup

package/packages/dd-trace/src/service-naming/index.js

@@ -30,7 +30,6 @@ class SchemaManager {
    * @param {string} kind
    * @param {string} plugin
    * @param {object} opts
-   * @returns {string}
    */
   opName (type, kind, plugin, opts) {
     return this.schema.getOpName(type, kind, plugin, opts)

package/packages/dd-trace/src/service-naming/schemas/util.js

@@ -37,7 +37,6 @@ function optionServiceSource ({ pluginConfig }) {
  * @param {{ service?: string | ((params?: object) => unknown) }} [pluginConfig]
  * @param {object} [params]
  * @param {string} defaultService
- * @returns {string}
  */
 function configServiceName (pluginConfig, params, defaultService) {
   const service = pluginConfig?.service

package/packages/dd-trace/src/service-naming/schemas/v0/storage.js

@@ -156,6 +156,13 @@ const storage = {
         return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'pg' })
       },
     },
+    postgres: {
+      opName: () => 'postgres.query',
+      serviceName: withSuffixFunction('postgres'),
+      serviceSource: ({ tracerService, pluginConfig, connectionName }) => {
+        return optionServiceSource({ tracerService, pluginConfig, connectionName, integration: 'postgres' })
+      },
+    },
     prisma: {
       opName: ({ operation }) => `prisma.${operation}`,
       serviceName: withSuffixFunction('prisma'),

package/packages/dd-trace/src/service-naming/schemas/v1/storage.js

@@ -86,6 +86,11 @@ const storage = {
       serviceName: withFunction,
       serviceSource: optionServiceSource,
     },
+    postgres: {
+      opName: () => 'postgresql.query',
+      serviceName: configWithFallback,
+      serviceSource: optionServiceSource,
+    },
     prisma: {
       opName: ({ operation }) => `prisma.${operation}`,
       serviceName: configWithFallback,

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

@@ -19,7 +19,8 @@ class SpanProcessor {
     this._config = config
     this._killAll = false
 
-    if (config.stats?.DD_TRACE_STATS_COMPUTATION_ENABLED && !config.appsec?.standalone?.enabled) {
+    if (config.stats?.DD_TRACE_STATS_COMPUTATION_ENABLED &&
+        !config.appsec?.DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED) {
       const { SpanStatsProcessor } = require('./span_stats')
       this._stats = new SpanStatsProcessor(config, otlpStatsExporter)
     }
@@ -45,7 +46,6 @@ class SpanProcessor {
    * `PrioritySampler.keepTrace()`), so `discard` only applies while the priority is still a reject.
    *
    * @param {import('./opentracing/span_context')} spanContext
-   * @returns {boolean}
    */
   #isDiscarded (spanContext) {
     return spanContext._sampling.discard && spanContext._sampling.priority <= AUTO_REJECT