dd-trace 5.39.0 → 5.40.0

package/index.d.ts

@@ -345,6 +345,12 @@ declare namespace tracer {
    * List of options available to the tracer.
    */
   export interface TracerOptions {
+    /**
+     * Used to disable APM Tracing when using standalone products
+     * @default true
+     */
+    apmTracingEnabled?: boolean
+
     /**
      * Whether to enable trace ID injection in log records to be able to correlate
      * traces with logs.
@@ -528,6 +534,9 @@ declare namespace tracer {
       appsec?: {
         /**
          * Configuration of Standalone ASM mode
+         * Deprecated in favor of `apmTracingEnabled`.
+         *
+         * @deprecated
          */
         standalone?: {
           /**
@@ -813,43 +822,43 @@ declare namespace tracer {
   export interface DogStatsD {
     /**
      * Increments a metric by the specified value, optionally specifying tags.
-     * @param {string} stat The dot-separated metric name.
-     * @param {number} value The amount to increment the stat by.
-     * @param {[tag:string]:string|number} tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
+     * @param stat The dot-separated metric name.
+     * @param value The amount to increment the stat by.
+     * @param tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
      */
-    increment(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+    increment(stat: string, value?: number, tags?: Record<string, string|number>): void
 
     /**
      * Decrements a metric by the specified value, optionally specifying tags.
-     * @param {string} stat The dot-separated metric name.
-     * @param {number} value The amount to decrement the stat by.
-     * @param {[tag:string]:string|number} tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
+     * @param stat The dot-separated metric name.
+     * @param value The amount to decrement the stat by.
+     * @param tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
      */
-    decrement(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+    decrement(stat: string, value?: number, tags?: Record<string, string|number>): void
 
     /**
      * Sets a distribution value, optionally specifying tags.
-     * @param {string} stat The dot-separated metric name.
-     * @param {number} value The amount to increment the stat by.
-     * @param {[tag:string]:string|number} tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
+     * @param stat The dot-separated metric name.
+     * @param value The amount to increment the stat by.
+     * @param tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
      */
-    distribution(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+    distribution(stat: string, value?: number, tags?: Record<string, string|number>): void
 
     /**
      * Sets a gauge value, optionally specifying tags.
-     * @param {string} stat The dot-separated metric name.
-     * @param {number} value The amount to increment the stat by.
-     * @param {[tag:string]:string|number} tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
+     * @param stat The dot-separated metric name.
+     * @param value The amount to increment the stat by.
+     * @param tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
      */
-    gauge(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+    gauge(stat: string, value?: number, tags?: Record<string, string|number>): void
 
     /**
      * Sets a histogram value, optionally specifying tags.
-     * @param {string} stat The dot-separated metric name.
-     * @param {number} value The amount to increment the stat by.
-     * @param {[tag:string]:string|number} tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
+     * @param stat The dot-separated metric name.
+     * @param value The amount to increment the stat by.
+     * @param tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
      */
-    histogram(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+    histogram(stat: string, value?: number, tags?: Record<string, string|number>): void
 
     /**
      * Forces any unsent metrics to be sent
@@ -871,7 +880,7 @@ declare namespace tracer {
 
     /**
      * Links a failed login event to the current trace.
-     * @param {string} userId The user id of the attemped login.
+     * @param {string} userId The user id of the attempted login.
      * @param {boolean} exists If the user id exists.
      * @param {[key: string]: string} metadata Custom fields to link to the login failure event.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.39.0",
+  "version": "5.40.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -24,7 +24,7 @@
     "test:appsec:plugins:ci": "yarn services && nyc --no-clean --include \"packages/dd-trace/src/appsec/**/*.js\" -- npm run test:appsec:plugins",
     "test:debugger": "mocha -r 'packages/dd-trace/test/setup/mocha.js' 'packages/dd-trace/test/debugger/**/*.spec.js'",
     "test:debugger:ci": "nyc --no-clean --include 'packages/dd-trace/src/debugger/**/*.js' -- npm run test:debugger",
-    "test:trace:core": "tap packages/dd-trace/test/*.spec.js \"packages/dd-trace/test/{ci-visibility,datastreams,encode,exporters,opentelemetry,opentracing,plugins,service-naming,telemetry}/**/*.spec.js\"",
+    "test:trace:core": "tap packages/dd-trace/test/*.spec.js \"packages/dd-trace/test/{ci-visibility,datastreams,encode,exporters,opentelemetry,opentracing,plugins,service-naming,standalone,telemetry}/**/*.spec.js\"",
     "test:trace:core:ci": "npm run test:trace:core -- --coverage --nyc-arg=--include=\"packages/dd-trace/src/**/*.js\"",
     "test:instrumentations": "mocha -r 'packages/dd-trace/test/setup/mocha.js' 'packages/datadog-instrumentations/test/**/*.spec.js'",
     "test:instrumentations:ci": "nyc --no-clean --include 'packages/datadog-instrumentations/src/**/*.js' -- npm run test:instrumentations",

package/packages/datadog-instrumentations/src/jest.js

@@ -147,10 +147,10 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
       if (this.isKnownTestsEnabled) {
         try {
-          const hasKnownTests = !!knownTests.jest
+          const hasKnownTests = !!knownTests?.jest
           earlyFlakeDetectionNumRetries = this.testEnvironmentOptions._ddEarlyFlakeDetectionNumRetries
           this.knownTestsForThisSuite = hasKnownTests
-            ? (knownTests.jest[this.testSuite] || [])
+            ? (knownTests?.jest[this.testSuite] || [])
             : this.getKnownTestsForSuite(this.testEnvironmentOptions._ddKnownTests)
         } catch (e) {
           // If there has been an error parsing the tests, we'll disable Early Flake Deteciton
@@ -442,6 +442,7 @@ addHook({
 }, getTestEnvironment)
 
 function getWrappedScheduleTests (scheduleTests, frameworkVersion) {
+  // `scheduleTests` is an async function
   return function (tests) {
     if (!isSuitesSkippingEnabled || hasFilteredSkippableSuites) {
       return scheduleTests.apply(this, arguments)
@@ -744,6 +745,7 @@ function coverageReporterWrapper (coverageReporter) {
    * This calculation adds no value, so we'll skip it, as long as the user has not manually opted in to code coverage,
    * in which case we'll leave it.
    */
+  // `_addUntestedFiles` is an async function
   shimmer.wrap(CoverageReporter.prototype, '_addUntestedFiles', addUntestedFiles => function () {
     // If the user has added coverage manually, they're willing to pay the price of this execution, so
     // we will not skip it.
@@ -901,6 +903,7 @@ addHook({
 }, transformPackage => {
   const originalCreateScriptTransformer = transformPackage.createScriptTransformer
 
+  // `createScriptTransformer` is an async function
   transformPackage.createScriptTransformer = function (config) {
     const { testEnvironmentOptions, ...restOfConfig } = config
     const {
@@ -951,7 +954,7 @@ addHook({
     if (isKnownTestsEnabled) {
       const projectSuites = testPaths.tests.map(test => getTestSuitePath(test.path, test.context.config.rootDir))
       const isFaulty =
-        getIsFaultyEarlyFlakeDetection(projectSuites, knownTests.jest || {}, earlyFlakeDetectionFaultyThreshold)
+        getIsFaultyEarlyFlakeDetection(projectSuites, knownTests?.jest || {}, earlyFlakeDetectionFaultyThreshold)
       if (isFaulty) {
         log.error('Early flake detection is disabled because the number of new suites is too high.')
         isEarlyFlakeDetectionEnabled = false
@@ -1063,7 +1066,7 @@ addHook({
       }
       const [{ globalConfig, config, path: testSuiteAbsolutePath }] = args
       const testSuite = getTestSuitePath(testSuiteAbsolutePath, globalConfig.rootDir || process.cwd())
-      const suiteKnownTests = knownTests.jest?.[testSuite] || []
+      const suiteKnownTests = knownTests?.jest?.[testSuite] || []
 
       const suiteQuarantinedTests = quarantinedTests.jest?.suites?.[testSuite]?.tests || {}
 

package/packages/datadog-instrumentations/src/mocha/main.js

@@ -349,6 +349,7 @@ addHook({
   versions: ['>=5.2.0'],
   file: 'lib/cli/run-helpers.js'
 }, (run) => {
+  // `runMocha` is an async function
   shimmer.wrap(run, 'runMocha', runMocha => function () {
     if (!testStartCh.hasSubscribers) {
       return runMocha.apply(this, arguments)

package/packages/datadog-instrumentations/src/nyc.js

@@ -7,6 +7,7 @@ addHook({
   name: 'nyc',
   versions: ['>=17']
 }, (nycPackage) => {
+  // `wrap` is an async function
   shimmer.wrap(nycPackage.prototype, 'wrap', wrap => function () {
     // Only relevant if the config `all` is set to true
     try {

package/packages/datadog-instrumentations/src/vitest.js

@@ -329,6 +329,7 @@ addHook({
   const { VitestTestRunner } = vitestPackage
 
   // `onBeforeRunTask` is run before any repetition or attempt is run
+  // `onBeforeRunTask` is an async function
   shimmer.wrap(VitestTestRunner.prototype, 'onBeforeRunTask', onBeforeRunTask => function (task) {
     const testName = getTestName(task)
 
@@ -361,6 +362,7 @@ addHook({
   })
 
   // `onAfterRunTask` is run after all repetitions or attempts are run
+  // `onAfterRunTask` is an async function
   shimmer.wrap(VitestTestRunner.prototype, 'onAfterRunTask', onAfterRunTask => function (task) {
     const { isEarlyFlakeDetectionEnabled, isQuarantinedTestsEnabled } = getProvidedContext()
 

package/packages/dd-trace/src/appsec/iast/index.js

@@ -22,7 +22,6 @@ const securityControls = require('./security-controls')
 const requestStart = dc.channel('dd-trace:incomingHttpRequestStart')
 const requestClose = dc.channel('dd-trace:incomingHttpRequestEnd')
 const iastResponseEnd = dc.channel('datadog:iast:response-end')
-
 let isEnabled = false
 
 function enable (config, _tracer) {

package/packages/dd-trace/src/appsec/iast/vulnerability-reporter.js

@@ -3,11 +3,10 @@
 const LRU = require('lru-cache')
 const vulnerabilitiesFormatter = require('./vulnerabilities-formatter')
 const { IAST_ENABLED_TAG_KEY, IAST_JSON_TAG_KEY } = require('./tags')
-const standalone = require('../standalone')
-const { SAMPLING_MECHANISM_APPSEC } = require('../../constants')
 const { keepTrace } = require('../../priority_sampler')
 const { reportStackTrace, getCallsiteFrames, canReportStackTrace, STACK_TRACE_NAMESPACES } = require('../stack_trace')
 const { getOriginalPathAndLineFromSourceMap } = require('./taint-tracking/rewriter')
+const { ASM } = require('../../standalone/product')
 
 const VULNERABILITIES_KEY = 'vulnerabilities'
 const VULNERABILITY_HASHES_MAX_SIZE = 1000
@@ -51,8 +50,7 @@ function addVulnerability (iastContext, vulnerability, callSiteFrames) {
 
   if (!span) return
 
-  keepTrace(span, SAMPLING_MECHANISM_APPSEC)
-  standalone.sample(span)
+  keepTrace(span, ASM)
 
   if (stackTraceEnabled && canReportStackTrace(span, maxStackTraces, STACK_TRACE_NAMESPACES.IAST)) {
     const originalCallSiteList = callSiteFrames.map(callsite => replaceCallSiteFromSourceMap(callsite))

package/packages/dd-trace/src/appsec/reporter.js

@@ -13,9 +13,8 @@ const {
   getRequestMetrics
 } = require('./telemetry')
 const zlib = require('zlib')
-const standalone = require('./standalone')
-const { SAMPLING_MECHANISM_APPSEC } = require('../constants')
 const { keepTrace } = require('../priority_sampler')
+const { ASM } = require('../standalone/product')
 
 // default limiter, configurable with setRateLimit()
 let limiter = new Limiter(100)
@@ -129,9 +128,7 @@ function reportAttack (attackData) {
   }
 
   if (limiter.isAllowed()) {
-    keepTrace(rootSpan, SAMPLING_MECHANISM_APPSEC)
-
-    standalone.sample(rootSpan)
+    keepTrace(rootSpan, ASM)
   }
 
   // TODO: maybe add this to format.js later (to take decision as late as possible)
@@ -186,9 +183,7 @@ function finishRequest (req, res) {
   if (metricsQueue.size) {
     rootSpan.addTags(Object.fromEntries(metricsQueue))
 
-    keepTrace(rootSpan, SAMPLING_MECHANISM_APPSEC)
-
-    standalone.sample(rootSpan)
+    keepTrace(rootSpan, ASM)
 
     metricsQueue.clear()
   }

package/packages/dd-trace/src/appsec/sdk/track_event.js

@@ -3,11 +3,10 @@
 const log = require('../../log')
 const { getRootSpan } = require('./utils')
 const { setUserTags } = require('./set_user')
-const standalone = require('../standalone')
 const waf = require('../waf')
-const { SAMPLING_MECHANISM_APPSEC } = require('../../constants')
 const { keepTrace } = require('../../priority_sampler')
 const addresses = require('../addresses')
+const { ASM } = require('../../standalone/product')
 
 function trackUserLoginSuccessEvent (tracer, user, metadata) {
   // TODO: better user check here and in _setUser() ?
@@ -79,8 +78,7 @@ function trackEvent (eventName, fields, sdkMethodName, rootSpan) {
 
   rootSpan.addTags(tags)
 
-  keepTrace(rootSpan, SAMPLING_MECHANISM_APPSEC)
-  standalone.sample(rootSpan)
+  keepTrace(rootSpan, ASM)
 }
 
 function runWaf (eventName, user) {

package/packages/dd-trace/src/appsec/telemetry/common.js

@@ -0,0 +1,24 @@
+'use strinct'
+
+const DD_TELEMETRY_REQUEST_METRICS = Symbol('_dd.appsec.telemetry.request.metrics')
+
+const tags = {
+  REQUEST_BLOCKED: 'request_blocked',
+  RULE_TRIGGERED: 'rule_triggered',
+  WAF_TIMEOUT: 'waf_timeout',
+  WAF_VERSION: 'waf_version',
+  EVENT_RULES_VERSION: 'event_rules_version'
+}
+
+function getVersionsTags (wafVersion, rulesVersion) {
+  return {
+    [tags.WAF_VERSION]: wafVersion,
+    [tags.EVENT_RULES_VERSION]: rulesVersion
+  }
+}
+
+module.exports = {
+  tags,
+  getVersionsTags,
+  DD_TELEMETRY_REQUEST_METRICS
+}

package/packages/dd-trace/src/appsec/telemetry/index.js

@@ -0,0 +1,126 @@
+'use strict'
+
+const { DD_TELEMETRY_REQUEST_METRICS } = require('./common')
+const { addRaspRequestMetrics, trackRaspMetrics } = require('./rasp')
+const { incrementMissingUserId, incrementMissingUserLogin } = require('./user')
+const {
+  addWafRequestMetrics,
+  trackWafMetrics,
+  incrementWafInit,
+  incrementWafUpdates,
+  incrementWafRequests
+} = require('./waf')
+
+const metricsStoreMap = new WeakMap()
+
+let enabled = false
+
+function enable (telemetryConfig) {
+  enabled = telemetryConfig?.enabled && telemetryConfig.metrics
+}
+
+function disable () {
+  enabled = false
+}
+
+function newStore () {
+  return {
+    [DD_TELEMETRY_REQUEST_METRICS]: {
+      duration: 0,
+      durationExt: 0,
+      raspDuration: 0,
+      raspDurationExt: 0,
+      raspEvalCount: 0
+    }
+  }
+}
+
+function getStore (req) {
+  let store = metricsStoreMap.get(req)
+  if (!store) {
+    store = newStore()
+    metricsStoreMap.set(req, store)
+  }
+  return store
+}
+
+function updateRaspRequestsMetricTags (metrics, req, raspRule) {
+  if (!req) return
+
+  const store = getStore(req)
+
+  // it does not depend on whether telemetry is enabled or not
+  addRaspRequestMetrics(store, metrics)
+
+  if (!enabled) return
+
+  trackRaspMetrics(metrics, raspRule)
+}
+
+function updateWafRequestsMetricTags (metrics, req) {
+  if (!req) return
+
+  const store = getStore(req)
+
+  // it does not depend on whether telemetry is enabled or not
+  addWafRequestMetrics(store, metrics)
+
+  if (!enabled) return
+
+  return trackWafMetrics(store, metrics)
+}
+
+function incrementWafInitMetric (wafVersion, rulesVersion) {
+  if (!enabled) return
+
+  incrementWafInit(wafVersion, rulesVersion)
+}
+
+function incrementWafUpdatesMetric (wafVersion, rulesVersion) {
+  if (!enabled) return
+
+  incrementWafUpdates(wafVersion, rulesVersion)
+}
+
+function incrementWafRequestsMetric (req) {
+  if (!req || !enabled) return
+
+  const store = getStore(req)
+  incrementWafRequests(store)
+
+  metricsStoreMap.delete(req)
+}
+
+function incrementMissingUserLoginMetric (framework, eventType) {
+  if (!enabled) return
+
+  incrementMissingUserLogin(framework, eventType)
+}
+
+function incrementMissingUserIdMetric (framework, eventType) {
+  if (!enabled) return
+
+  incrementMissingUserId(framework, eventType)
+}
+
+function getRequestMetrics (req) {
+  if (req) {
+    const store = getStore(req)
+    return store?.[DD_TELEMETRY_REQUEST_METRICS]
+  }
+}
+
+module.exports = {
+  enable,
+  disable,
+
+  updateWafRequestsMetricTags,
+  updateRaspRequestsMetricTags,
+  incrementWafInitMetric,
+  incrementWafUpdatesMetric,
+  incrementWafRequestsMetric,
+  incrementMissingUserLoginMetric,
+  incrementMissingUserIdMetric,
+
+  getRequestMetrics
+}

package/packages/dd-trace/src/appsec/telemetry/rasp.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const telemetryMetrics = require('../../telemetry/metrics')
+const { DD_TELEMETRY_REQUEST_METRICS } = require('./common')
+
+const appsecMetrics = telemetryMetrics.manager.namespace('appsec')
+
+function addRaspRequestMetrics (store, { duration, durationExt }) {
+  store[DD_TELEMETRY_REQUEST_METRICS].raspDuration += duration || 0
+  store[DD_TELEMETRY_REQUEST_METRICS].raspDurationExt += durationExt || 0
+  store[DD_TELEMETRY_REQUEST_METRICS].raspEvalCount++
+}
+
+function trackRaspMetrics (metrics, raspRule) {
+  const tags = { rule_type: raspRule.type, waf_version: metrics.wafVersion }
+
+  if (raspRule.variant) {
+    tags.rule_variant = raspRule.variant
+  }
+
+  appsecMetrics.count('rasp.rule.eval', tags).inc(1)
+
+  if (metrics.wafTimeout) {
+    appsecMetrics.count('rasp.timeout', tags).inc(1)
+  }
+
+  if (metrics.ruleTriggered) {
+    appsecMetrics.count('rasp.rule.match', tags).inc(1)
+  }
+}
+
+module.exports = {
+  addRaspRequestMetrics,
+  trackRaspMetrics
+}

package/packages/dd-trace/src/appsec/telemetry/user.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const telemetryMetrics = require('../../telemetry/metrics')
+
+const appsecMetrics = telemetryMetrics.manager.namespace('appsec')
+
+function incrementMissingUserLogin (framework, eventType) {
+  appsecMetrics.count('instrum.user_auth.missing_user_login', {
+    framework,
+    event_type: eventType
+  }).inc()
+}
+
+function incrementMissingUserId (framework, eventType) {
+  appsecMetrics.count('instrum.user_auth.missing_user_id', {
+    framework,
+    event_type: eventType
+  }).inc()
+}
+
+module.exports = {
+  incrementMissingUserLogin,
+  incrementMissingUserId
+}

package/packages/dd-trace/src/appsec/telemetry/waf.js

@@ -0,0 +1,92 @@
+'use strict'
+
+const telemetryMetrics = require('../../telemetry/metrics')
+const { tags, getVersionsTags, DD_TELEMETRY_REQUEST_METRICS } = require('./common')
+
+const appsecMetrics = telemetryMetrics.manager.namespace('appsec')
+
+const DD_TELEMETRY_WAF_RESULT_TAGS = Symbol('_dd.appsec.telemetry.waf.result.tags')
+
+function addWafRequestMetrics (store, { duration, durationExt }) {
+  store[DD_TELEMETRY_REQUEST_METRICS].duration += duration || 0
+  store[DD_TELEMETRY_REQUEST_METRICS].durationExt += durationExt || 0
+}
+
+function trackWafDurations ({ duration, durationExt }, versionsTags) {
+  if (duration) {
+    appsecMetrics.distribution('waf.duration', versionsTags).track(duration)
+  }
+
+  if (durationExt) {
+    appsecMetrics.distribution('waf.duration_ext', versionsTags).track(durationExt)
+  }
+}
+
+function trackWafMetrics (store, metrics) {
+  const versionsTags = getVersionsTags(metrics.wafVersion, metrics.rulesVersion)
+
+  trackWafDurations(metrics, versionsTags)
+
+  const metricTags = getOrCreateMetricTags(store, versionsTags)
+
+  const { blockTriggered, ruleTriggered, wafTimeout } = metrics
+
+  if (blockTriggered) {
+    metricTags[tags.REQUEST_BLOCKED] = true
+  }
+
+  if (ruleTriggered) {
+    metricTags[tags.RULE_TRIGGERED] = true
+  }
+
+  if (wafTimeout) {
+    metricTags[tags.WAF_TIMEOUT] = true
+  }
+
+  return metricTags
+}
+
+function getOrCreateMetricTags (store, versionsTags) {
+  let metricTags = store[DD_TELEMETRY_WAF_RESULT_TAGS]
+
+  if (!metricTags) {
+    metricTags = {
+      [tags.REQUEST_BLOCKED]: false,
+      [tags.RULE_TRIGGERED]: false,
+      [tags.WAF_TIMEOUT]: false,
+
+      ...versionsTags
+    }
+    store[DD_TELEMETRY_WAF_RESULT_TAGS] = metricTags
+  }
+
+  return metricTags
+}
+
+function incrementWafInit (wafVersion, rulesVersion) {
+  const versionsTags = getVersionsTags(wafVersion, rulesVersion)
+
+  appsecMetrics.count('waf.init', versionsTags).inc()
+}
+
+function incrementWafUpdates (wafVersion, rulesVersion) {
+  const versionsTags = getVersionsTags(wafVersion, rulesVersion)
+
+  appsecMetrics.count('waf.updates', versionsTags).inc()
+}
+
+function incrementWafRequests (store) {
+  const metricTags = store[DD_TELEMETRY_WAF_RESULT_TAGS]
+
+  if (metricTags) {
+    appsecMetrics.count('waf.requests', metricTags).inc()
+  }
+}
+
+module.exports = {
+  addWafRequestMetrics,
+  trackWafMetrics,
+  incrementWafInit,
+  incrementWafUpdates,
+  incrementWafRequests
+}

package/packages/dd-trace/src/appsec/user_tracking.js

@@ -5,9 +5,8 @@ const log = require('../log')
 const telemetry = require('./telemetry')
 const addresses = require('./addresses')
 const { keepTrace } = require('../priority_sampler')
-const { SAMPLING_MECHANISM_APPSEC } = require('../constants')
-const standalone = require('./standalone')
 const waf = require('./waf')
+const { ASM } = require('../standalone/product')
 
 // the RFC doesn't include '_id', but it's common in MongoDB
 const USER_ID_FIELDS = ['id', '_id', 'email', 'username', 'login', 'user']
@@ -151,8 +150,7 @@ function trackLogin (framework, login, user, success, rootSpan) {
     persistent[addresses.LOGIN_FAILURE] = null
   }
 
-  keepTrace(rootSpan, SAMPLING_MECHANISM_APPSEC)
-  standalone.sample(rootSpan)
+  keepTrace(rootSpan, ASM)
 
   rootSpan.addTags(newTags)
 

package/packages/dd-trace/src/ci-visibility/dynamic-instrumentation/index.js

@@ -9,7 +9,8 @@ const probeIdToResolveBreakpointSet = new Map()
 const probeIdToResolveBreakpointRemove = new Map()
 
 class TestVisDynamicInstrumentation {
-  constructor () {
+  constructor (config) {
+    this._config = config
     this.worker = null
     this._readyPromise = new Promise(resolve => {
       this._onReady = resolve
@@ -32,6 +33,9 @@ class TestVisDynamicInstrumentation {
   // 1. Probe ID
   // 2. Promise that's resolved when the breakpoint is set
   addLineProbe ({ file, line }, onHitBreakpoint) {
+    if (!this.worker) { // not init yet
+      this.start()
+    }
     const probeId = randomUUID()
 
     this.breakpointSetChannel.port2.postMessage(
@@ -52,7 +56,7 @@ class TestVisDynamicInstrumentation {
     return this._readyPromise
   }
 
-  start (config) {
+  start () {
     if (this.worker) return
 
     log.debug('Starting Test Visibility - Dynamic Instrumentation client...')
@@ -77,7 +81,7 @@ class TestVisDynamicInstrumentation {
           DD_TRACE_TELEMETRY_ENABLED: 0
         },
         workerData: {
-          config: config.serialize(),
+          config: this._config.serialize(),
           parentThreadId,
           rcPort: rcChannel.port1,
           configPort: configChannel.port1,
@@ -138,4 +142,12 @@ class TestVisDynamicInstrumentation {
   }
 }
 
-module.exports = new TestVisDynamicInstrumentation()
+let dynamicInstrumentation
+
+module.exports = (config) => {
+  if (dynamicInstrumentation) {
+    return dynamicInstrumentation
+  }
+  dynamicInstrumentation = new TestVisDynamicInstrumentation(config)
+  return dynamicInstrumentation
+}