dd-trace 3.55.0 → 3.56.0

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

@@ -1,5 +1,6 @@
 module.exports = {
   COMMAND_INJECTION: 'COMMAND_INJECTION',
+  HARDCODED_PASSWORD: 'HARDCODED_PASSWORD',
   HARDCODED_SECRET: 'HARDCODED_SECRET',
   HEADER_INJECTION: 'HEADER_INJECTION',
   HSTS_HEADER_MISSING: 'HSTS_HEADER_MISSING',

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

@@ -8,7 +8,8 @@ const {
   incrementWafInitMetric,
   updateWafRequestsMetricTags,
   incrementWafUpdatesMetric,
-  incrementWafRequestsMetric
+  incrementWafRequestsMetric,
+  getRequestMetrics
 } = require('./telemetry')
 const zlib = require('zlib')
 
@@ -92,19 +93,10 @@ function reportWafInit (wafVersion, rulesVersion, diagnosticsRules = {}) {
 }
 
 function reportMetrics (metrics) {
-  // TODO: metrics should be incremental, there already is an RFC to report metrics
   const store = storage.getStore()
   const rootSpan = store?.req && web.root(store.req)
   if (!rootSpan) return
 
-  if (metrics.duration) {
-    rootSpan.setTag('_dd.appsec.waf.duration', metrics.duration)
-  }
-
-  if (metrics.durationExt) {
-    rootSpan.setTag('_dd.appsec.waf.duration_ext', metrics.durationExt)
-  }
-
   if (metrics.rulesVersion) {
     rootSpan.setTag('_dd.appsec.event_rules.version', metrics.rulesVersion)
   }
@@ -179,6 +171,15 @@ function finishRequest (req, res) {
     metricsQueue.clear()
   }
 
+  const metrics = getRequestMetrics(req)
+  if (metrics?.duration) {
+    rootSpan.setTag('_dd.appsec.waf.duration', metrics.duration)
+  }
+
+  if (metrics?.durationExt) {
+    rootSpan.setTag('_dd.appsec.waf.duration_ext', metrics.durationExt)
+  }
+
   incrementWafRequestsMetric(req)
 
   // collect some headers even when no attack is detected

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

@@ -5,6 +5,7 @@ const telemetryMetrics = require('../telemetry/metrics')
 const appsecMetrics = telemetryMetrics.manager.namespace('appsec')
 
 const DD_TELEMETRY_WAF_RESULT_TAGS = Symbol('_dd.appsec.telemetry.waf.result.tags')
+const DD_TELEMETRY_REQUEST_METRICS = Symbol('_dd.appsec.telemetry.request.metrics')
 
 const tags = {
   REQUEST_BLOCKED: 'request_blocked',
@@ -26,10 +27,19 @@ function disable () {
   enabled = false
 }
 
+function newStore () {
+  return {
+    [DD_TELEMETRY_REQUEST_METRICS]: {
+      duration: 0,
+      durationExt: 0
+    }
+  }
+}
+
 function getStore (req) {
   let store = metricsStoreMap.get(req)
   if (!store) {
-    store = {}
+    store = newStore()
     metricsStoreMap.set(req, store)
   }
   return store
@@ -51,9 +61,7 @@ function trackWafDurations (metrics, versionsTags) {
   }
 }
 
-function getOrCreateMetricTags (req, versionsTags) {
-  const store = getStore(req)
-
+function getOrCreateMetricTags (store, versionsTags) {
   let metricTags = store[DD_TELEMETRY_WAF_RESULT_TAGS]
   if (!metricTags) {
     metricTags = {
@@ -69,13 +77,20 @@ function getOrCreateMetricTags (req, versionsTags) {
 }
 
 function updateWafRequestsMetricTags (metrics, req) {
-  if (!req || !enabled) return
+  if (!req) return
+
+  const store = getStore(req)
+
+  // it does not depend on whether telemetry is enabled or not
+  addRequestMetrics(store, metrics)
+
+  if (!enabled) return
 
   const versionsTags = getVersionsTags(metrics.wafVersion, metrics.rulesVersion)
 
   trackWafDurations(metrics, versionsTags)
 
-  const metricTags = getOrCreateMetricTags(req, versionsTags)
+  const metricTags = getOrCreateMetricTags(store, versionsTags)
 
   const { blockTriggered, ruleTriggered, wafTimeout } = metrics
 
@@ -121,6 +136,18 @@ function incrementWafRequestsMetric (req) {
   metricsStoreMap.delete(req)
 }
 
+function addRequestMetrics (store, { duration, durationExt }) {
+  store[DD_TELEMETRY_REQUEST_METRICS].duration += duration || 0
+  store[DD_TELEMETRY_REQUEST_METRICS].durationExt += durationExt || 0
+}
+
+function getRequestMetrics (req) {
+  if (req) {
+    const store = getStore(req)
+    return store?.[DD_TELEMETRY_REQUEST_METRICS]
+  }
+}
+
 module.exports = {
   enable,
   disable,
@@ -128,5 +155,7 @@ module.exports = {
   updateWafRequestsMetricTags,
   incrementWafInitMetric,
   incrementWafUpdatesMetric,
-  incrementWafRequestsMetric
+  incrementWafRequestsMetric,
+
+  getRequestMetrics
 }

package/packages/dd-trace/src/ci-visibility/exporters/ci-visibility-exporter.js

@@ -189,7 +189,8 @@ class CiVisibilityExporter extends AgentInfoExporter {
       isItrEnabled,
       requireGit,
       isEarlyFlakeDetectionEnabled,
-      earlyFlakeDetectionNumRetries
+      earlyFlakeDetectionNumRetries,
+      earlyFlakeDetectionFaultyThreshold
     } = remoteConfiguration
     return {
       isCodeCoverageEnabled,
@@ -197,7 +198,8 @@ class CiVisibilityExporter extends AgentInfoExporter {
       isItrEnabled,
       requireGit,
       isEarlyFlakeDetectionEnabled: isEarlyFlakeDetectionEnabled && this._config.isEarlyFlakeDetectionEnabled,
-      earlyFlakeDetectionNumRetries
+      earlyFlakeDetectionNumRetries,
+      earlyFlakeDetectionFaultyThreshold
     }
   }
 

package/packages/dd-trace/src/ci-visibility/requests/get-library-configuration.js

@@ -12,6 +12,7 @@ const {
 } = require('../telemetry')
 
 const DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES = 2
+const DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD = 30
 
 function getLibraryConfiguration ({
   url,
@@ -104,7 +105,9 @@ function getLibraryConfiguration ({
           requireGit,
           isEarlyFlakeDetectionEnabled: earlyFlakeDetectionConfig?.enabled ?? false,
           earlyFlakeDetectionNumRetries:
-            earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] || DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES
+            earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] || DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
+          earlyFlakeDetectionFaultyThreshold:
+            earlyFlakeDetectionConfig?.faulty_session_threshold ?? DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD
         }
 
         log.debug(() => `Remote settings: ${JSON.stringify(settings)}`)

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

@@ -15,9 +15,65 @@ const { isTrue, isFalse } = require('./util')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('./plugins/util/tags')
 const { getGitMetadataFromGitProperties, removeUserSensitiveInfo } = require('./git_properties')
 const { updateConfig } = require('./telemetry')
+const telemetryMetrics = require('./telemetry/metrics')
 const { getIsGCPFunction, getIsAzureFunctionConsumptionPlan } = require('./serverless')
 const { ORIGIN_KEY } = require('./constants')
 
+const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
+
+const telemetryCounters = {
+  'otel.env.hiding': {},
+  'otel.env.invalid': {}
+}
+
+function getCounter (event, ddVar, otelVar, otelTracesSamplerArg) {
+  const counters = telemetryCounters[event]
+  const tags = []
+
+  if (ddVar) tags.push(ddVar)
+  if (otelVar) tags.push(otelVar)
+  if (otelTracesSamplerArg) tags.push(otelTracesSamplerArg)
+
+  if (!(ddVar in counters)) counters[ddVar] = {}
+
+  const counter = tracerMetrics.count(event, tags)
+  counters[ddVar][otelVar] = counter
+  return counter
+}
+
+const otelDdEnvMapping = {
+  DD_TRACE_LOG_LEVEL: 'OTEL_LOG_LEVEL',
+  DD_TRACE_PROPAGATION_STYLE: 'OTEL_PROPAGATORS',
+  DD_SERVICE: 'OTEL_SERVICE_NAME',
+  DD_TRACE_SAMPLE_RATE: 'OTEL_TRACES_SAMPLER',
+  DD_TRACE_ENABLED: 'OTEL_TRACES_EXPORTER',
+  DD_RUNTIME_METRICS_ENABLED: 'OTEL_METRICS_EXPORTER',
+  DD_TAGS: 'OTEL_RESOURCE_ATTRIBUTES',
+  DD_TRACE_OTEL_ENABLED: 'OTEL_SDK_DISABLED'
+}
+
+const otelInvalidEnv = ['OTEL_LOGS_EXPORTER']
+
+function checkIfBothOtelAndDdEnvVarSet () {
+  for (const [ddVar, otelVar] of Object.entries(otelDdEnvMapping)) {
+    if (process.env[ddVar] && process.env[otelVar]) {
+      log.warn(`both ${ddVar} and ${otelVar} environment variables are set`)
+      getCounter('otel.env.hiding', ddVar, otelVar,
+        otelVar === 'OTEL_TRACES_SAMPLER' &&
+        process.env.OTEL_TRACES_SAMPLER_ARG
+          ? 'OTEL_TRACES_SAMPLER_ARG'
+          : undefined).inc()
+    }
+  }
+
+  for (const otelVar of otelInvalidEnv) {
+    if (process.env[otelVar]) {
+      log.warn(`${otelVar} is not supported by the Datadog SDK`)
+      getCounter('otel.env.invalid', otelVar).inc()
+    }
+  }
+}
+
 const fromEntries = Object.fromEntries || (entries =>
   entries.reduce((obj, [k, v]) => Object.assign(obj, { [k]: v }), {}))
 
@@ -89,7 +145,8 @@ function propagationStyle (key, option, defaultValue) {
 
   // Otherwise, fallback to env var parsing
   const envKey = `DD_TRACE_PROPAGATION_STYLE_${key.toUpperCase()}`
-  const envVar = coalesce(process.env[envKey], process.env.DD_TRACE_PROPAGATION_STYLE)
+
+  const envVar = coalesce(process.env[envKey], process.env.DD_TRACE_PROPAGATION_STYLE, process.env.OTEL_PROPAGATORS)
   if (typeof envVar !== 'undefined') {
     return envVar.split(',')
       .filter(v => v !== '')
@@ -108,15 +165,19 @@ class Config {
       iastOptions: options.experimental?.iast
     }
 
+    checkIfBothOtelAndDdEnvVarSet()
+
     // Configure the logger first so it can be used to warn about other configs
     this.debug = isTrue(coalesce(
       process.env.DD_TRACE_DEBUG,
       false
     ))
     this.logger = options.logger
+
     this.logLevel = coalesce(
       options.logLevel,
       process.env.DD_TRACE_LOG_LEVEL,
+      process.env.OTEL_LOG_LEVEL,
       'debug'
     )
 
@@ -163,12 +224,12 @@ class Config {
         'environment variables'
       )
     }
-    const DD_TRACE_PROPAGATION_STYLE_INJECT = propagationStyle(
+    const PROPAGATION_STYLE_INJECT = propagationStyle(
       'inject',
       options.tracePropagationStyle,
       defaultPropagationStyle
     )
-    const DD_TRACE_PROPAGATION_STYLE_EXTRACT = propagationStyle(
+    const PROPAGATION_STYLE_EXTRACT = propagationStyle(
       'extract',
       options.tracePropagationStyle,
       defaultPropagationStyle
@@ -253,8 +314,13 @@ class Config {
     this.apiKey = DD_API_KEY
     this.serviceMapping = DD_SERVICE_MAPPING
     this.tracePropagationStyle = {
-      inject: DD_TRACE_PROPAGATION_STYLE_INJECT,
-      extract: DD_TRACE_PROPAGATION_STYLE_EXTRACT
+      inject: PROPAGATION_STYLE_INJECT,
+      extract: PROPAGATION_STYLE_EXTRACT,
+      otelPropagators: process.env.DD_TRACE_PROPAGATION_STYLE ||
+        process.env.DD_TRACE_PROPAGATION_STYLE_INJECT ||
+        process.env.DD_TRACE_PROPAGATION_STYLE_EXTRACT
+        ? false
+        : !!process.env.OTEL_PROPAGATORS
     }
     this.tracePropagationExtractFirst = isTrue(DD_TRACE_PROPAGATION_EXTRACT_FIRST)
     this.sampler = sampler
@@ -526,12 +592,18 @@ class Config {
       DD_TRACE_TELEMETRY_ENABLED,
       DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH,
       DD_TRACING_ENABLED,
-      DD_VERSION
+      DD_VERSION,
+      OTEL_SERVICE_NAME,
+      OTEL_RESOURCE_ATTRIBUTES,
+      OTEL_TRACES_SAMPLER,
+      OTEL_TRACES_SAMPLER_ARG,
+      OTEL_METRICS_EXPORTER
     } = process.env
 
     const tags = {}
     const env = this._env = {}
 
+    tagger.add(tags, OTEL_RESOURCE_ATTRIBUTES, true)
     tagger.add(tags, DD_TAGS)
     tagger.add(tags, DD_TRACE_TAGS)
     tagger.add(tags, DD_TRACE_GLOBAL_TAGS)
@@ -592,11 +664,24 @@ class Config {
     ))
     this._setValue(env, 'remoteConfig.pollInterval', maybeFloat(DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS))
     this._setBoolean(env, 'reportHostname', DD_TRACE_REPORT_HOSTNAME)
-    this._setBoolean(env, 'runtimeMetrics', DD_RUNTIME_METRICS_ENABLED)
-    this._setUnit(env, 'sampleRate', DD_TRACE_SAMPLE_RATE)
+    // only used to explicitly set runtimeMetrics to false
+    const otelSetRuntimeMetrics = String(OTEL_METRICS_EXPORTER).toLowerCase() === 'none'
+      ? false
+      : undefined
+    this._setBoolean(env, 'runtimeMetrics', DD_RUNTIME_METRICS_ENABLED ||
+    otelSetRuntimeMetrics)
+    const OTEL_TRACES_SAMPLER_MAPPING = {
+      always_on: '1.0',
+      always_off: '0.0',
+      traceidratio: OTEL_TRACES_SAMPLER_ARG,
+      parentbased_always_on: '1.0',
+      parentbased_always_off: '0.0',
+      parentbased_traceidratio: OTEL_TRACES_SAMPLER_ARG
+    }
+    this._setUnit(env, 'sampleRate', DD_TRACE_SAMPLE_RATE || OTEL_TRACES_SAMPLER_MAPPING[OTEL_TRACES_SAMPLER])
     this._setValue(env, 'sampler.rateLimit', DD_TRACE_RATE_LIMIT)
     this._setString(env, 'scope', DD_TRACE_SCOPE)
-    this._setString(env, 'service', DD_SERVICE || DD_SERVICE_NAME || tags.service)
+    this._setString(env, 'service', DD_SERVICE || DD_SERVICE_NAME || tags.service || OTEL_SERVICE_NAME)
     this._setString(env, 'site', DD_SITE)
     if (DD_TRACE_SPAN_ATTRIBUTE_SCHEMA) {
       this._setString(env, 'spanAttributeSchema', validateNamingVersion(DD_TRACE_SPAN_ATTRIBUTE_SCHEMA))

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

@@ -12,6 +12,7 @@ const MAX_BUFFER_SIZE = 1024 // limit from the agent
 const TYPE_COUNTER = 'c'
 const TYPE_GAUGE = 'g'
 const TYPE_DISTRIBUTION = 'd'
+const TYPE_HISTOGRAM = 'h'
 
 class DogStatsDClient {
   constructor (options = {}) {
@@ -46,6 +47,10 @@ class DogStatsDClient {
     this._add(stat, value, TYPE_DISTRIBUTION, tags)
   }
 
+  histogram (stat, value, tags) {
+    this._add(stat, value, TYPE_HISTOGRAM, tags)
+  }
+
   flush () {
     const queue = this._enqueue()
 
@@ -180,16 +185,6 @@ class DogStatsDClient {
   }
 }
 
-class NoopDogStatsDClient {
-  gauge () { }
-
-  increment () { }
-
-  distribution () { }
-
-  flush () { }
-}
-
 // This is a simplified user-facing proxy to the underlying DogStatsDClient instance
 class CustomMetrics {
   constructor (config) {
@@ -229,6 +224,14 @@ class CustomMetrics {
     )
   }
 
+  histogram (stat, value, tags) {
+    return this.dogstatsd.histogram(
+      stat,
+      value,
+      CustomMetrics.tagTranslator(tags)
+    )
+  }
+
   flush () {
     return this.dogstatsd.flush()
   }
@@ -252,6 +255,5 @@ class CustomMetrics {
 
 module.exports = {
   DogStatsDClient,
-  NoopDogStatsDClient,
   CustomMetrics
 }

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

@@ -5,6 +5,10 @@ const { isFalse } = require('./util')
 // Global `jest` is only present in Jest workers.
 const inJestWorker = typeof jest !== 'undefined'
 
-module.exports = isFalse(process.env.DD_TRACE_ENABLED) || inJestWorker
+const ddTraceDisabled = process.env.DD_TRACE_ENABLED
+  ? isFalse(process.env.DD_TRACE_ENABLED)
+  : String(process.env.OTEL_TRACES_EXPORTER).toLowerCase() === 'none'
+
+module.exports = ddTraceDisabled || inJestWorker
   ? require('./noop/proxy')
   : require('./proxy')

package/packages/dd-trace/src/noop/dogstatsd.js

@@ -0,0 +1,11 @@
+module.exports = class NoopDogStatsDClient {
+  increment () { }
+
+  gauge () { }
+
+  distribution () { }
+
+  histogram () { }
+
+  flush () { }
+}

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

@@ -2,14 +2,17 @@
 
 const NoopTracer = require('./tracer')
 const NoopAppsecSdk = require('../appsec/sdk/noop')
+const NoopDogStatsDClient = require('./dogstatsd')
 
 const noop = new NoopTracer()
 const noopAppsec = new NoopAppsecSdk()
+const noopDogStatsDClient = new NoopDogStatsDClient()
 
 class Tracer {
   constructor () {
     this._tracer = noop
     this.appsec = noopAppsec
+    this.dogstatsd = noopDogStatsDClient
   }
 
   init () {

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -224,13 +224,19 @@ class TextMapPropagator {
         case 'tracecontext':
           spanContext = this._extractTraceparentContext(carrier)
           break
-        case 'b3': // TODO: should match "b3 single header" in next major
-        case 'b3multi':
-          spanContext = this._extractB3MultiContext(carrier)
-          break
+        case 'b3' && this
+          ._config
+          .tracePropagationStyle
+          .otelPropagators: // TODO: should match "b3 single header" in next major
         case 'b3 single header': // TODO: delete in major after singular "b3"
           spanContext = this._extractB3SingleContext(carrier)
           break
+        case 'b3':
+        case 'b3multi':
+          spanContext = this._extractB3MultiContext(carrier)
+          break
+        default:
+          log.warn(`Unknown propagation style: ${extractor}`)
       }
 
       if (spanContext !== null) {

package/packages/dd-trace/src/opentracing/span.js

@@ -33,6 +33,7 @@ const integrationCounters = {
   spans_finished: {}
 }
 
+const startCh = channel('dd-trace:span:start')
 const finishCh = channel('dd-trace:span:finish')
 
 function getIntegrationCounter (event, integration) {
@@ -96,6 +97,7 @@ class DatadogSpan {
       unfinishedRegistry.register(this, operationName, this)
     }
     spanleak.addSpan(this, operationName)
+    startCh.publish(this)
   }
 
   toString () {

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

@@ -45,6 +45,7 @@ module.exports = {
   get 'jest-environment-node' () { return require('../../../datadog-plugin-jest/src') },
   get 'jest-environment-jsdom' () { return require('../../../datadog-plugin-jest/src') },
   get 'jest-jasmine2' () { return require('../../../datadog-plugin-jest/src') },
+  get 'jest-runtime' () { return require('../../../datadog-plugin-jest/src') },
   get 'jest-worker' () { return require('../../../datadog-plugin-jest/src') },
   get koa () { return require('../../../datadog-plugin-koa/src') },
   get 'koa-router' () { return require('../../../datadog-plugin-koa/src') },
@@ -77,6 +78,7 @@ module.exports = {
   get restify () { return require('../../../datadog-plugin-restify/src') },
   get rhea () { return require('../../../datadog-plugin-rhea/src') },
   get router () { return require('../../../datadog-plugin-router/src') },
+  get 'selenium-webdriver' () { return require('../../../datadog-plugin-selenium/src') },
   get sharedb () { return require('../../../datadog-plugin-sharedb/src') },
   get tedious () { return require('../../../datadog-plugin-tedious/src') },
   get winston () { return require('../../../datadog-plugin-winston/src') }

package/packages/dd-trace/src/plugins/util/test.js

@@ -53,7 +53,8 @@ const TEST_CONFIGURATION_BROWSER_NAME = 'test.configuration.browser_name'
 // Early flake detection
 const TEST_IS_NEW = 'test.is_new'
 const TEST_IS_RETRY = 'test.is_retry'
-const TEST_EARLY_FLAKE_IS_ENABLED = 'test.early_flake.is_enabled'
+const TEST_EARLY_FLAKE_ENABLED = 'test.early_flake.enabled'
+const TEST_EARLY_FLAKE_ABORT_REASON = 'test.early_flake.abort_reason'
 
 const CI_APP_ORIGIN = 'ciapp-test'
 
@@ -71,6 +72,12 @@ const ITR_CORRELATION_ID = 'itr_correlation_id'
 
 const TEST_CODE_COVERAGE_LINES_PCT = 'test.code_coverage.lines_pct'
 
+// selenium tags
+const TEST_BROWSER_DRIVER = 'test.browser.driver'
+const TEST_BROWSER_DRIVER_VERSION = 'test.browser.driver_version'
+const TEST_BROWSER_NAME = 'test.browser.name'
+const TEST_BROWSER_VERSION = 'test.browser.version'
+
 // jest worker variables
 const JEST_WORKER_TRACE_PAYLOAD_CODE = 60
 const JEST_WORKER_COVERAGE_PAYLOAD_CODE = 61
@@ -102,7 +109,8 @@ module.exports = {
   TEST_CONFIGURATION_BROWSER_NAME,
   TEST_IS_NEW,
   TEST_IS_RETRY,
-  TEST_EARLY_FLAKE_IS_ENABLED,
+  TEST_EARLY_FLAKE_ENABLED,
+  TEST_EARLY_FLAKE_ABORT_REASON,
   getTestEnvironmentMetadata,
   getTestParametersString,
   finishAllTraceSpans,
@@ -141,7 +149,12 @@ module.exports = {
   EFD_STRING,
   EFD_TEST_NAME_REGEX,
   removeEfdStringFromTestName,
-  addEfdStringToTestName
+  addEfdStringToTestName,
+  getIsFaultyEarlyFlakeDetection,
+  TEST_BROWSER_DRIVER,
+  TEST_BROWSER_DRIVER_VERSION,
+  TEST_BROWSER_NAME,
+  TEST_BROWSER_VERSION
 }
 
 // Returns pkg manager and its version, separated by '-', e.g. npm-8.15.0 or yarn-1.22.19
@@ -571,3 +584,21 @@ function addEfdStringToTestName (testName, numAttempt) {
 function removeEfdStringFromTestName (testName) {
   return testName.replace(EFD_TEST_NAME_REGEX, '')
 }
+
+function getIsFaultyEarlyFlakeDetection (projectSuites, testsBySuiteName, faultyThresholdPercentage) {
+  let newSuites = 0
+  for (const suite of projectSuites) {
+    if (!testsBySuiteName[suite]) {
+      newSuites++
+    }
+  }
+  const newSuitesPercentage = (newSuites / projectSuites.length) * 100
+
+  // The faulty threshold represents a percentage, but we also want to consider
+  // smaller projects, where big variations in the % are more likely.
+  // This is why we also check the absolute number of new suites.
+  return (
+    newSuites > faultyThresholdPercentage &&
+    newSuitesPercentage > faultyThresholdPercentage
+  )
+}

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

@@ -21,6 +21,7 @@ class Config {
       DD_AGENT_HOST,
       DD_ENV,
       DD_PROFILING_CODEHOTSPOTS_ENABLED,
+      DD_PROFILING_CPU_ENABLED,
       DD_PROFILING_DEBUG_SOURCE_MAPS,
       DD_PROFILING_ENABLED,
       DD_PROFILING_ENDPOINT_COLLECTION_ENABLED,
@@ -165,7 +166,7 @@ class Config {
 
     this.timelineEnabled = isTrue(coalesce(options.timelineEnabled,
       DD_PROFILING_TIMELINE_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED, false))
+      DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED, samplingContextsAvailable))
     logExperimentalVarDeprecation('TIMELINE_ENABLED')
     checkOptionWithSamplingContextAllowed(this.timelineEnabled, 'Timeline view')
 
@@ -176,7 +177,9 @@ class Config {
     checkOptionWithSamplingContextAllowed(this.codeHotspotsEnabled, 'Code hotspots')
 
     this.cpuProfilingEnabled = isTrue(coalesce(options.cpuProfilingEnabled,
-      DD_PROFILING_EXPERIMENTAL_CPU_ENABLED, false))
+      DD_PROFILING_CPU_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_CPU_ENABLED, samplingContextsAvailable))
+    logExperimentalVarDeprecation('CPU_ENABLED')
     checkOptionWithSamplingContextAllowed(this.cpuProfilingEnabled, 'CPU profiling')
 
     this.profilers = ensureProfilers(profilers, this)
@@ -288,8 +291,9 @@ function ensureProfilers (profilers, options) {
     }
   }
 
-  // Events profiler is a profiler for timeline events
-  if (options.timelineEnabled) {
+  // Events profiler is a profiler that produces timeline events. It is only
+  // added if timeline is enabled and there's a wall profiler.
+  if (options.timelineEnabled && profilers.some(p => p instanceof WallProfiler)) {
     profilers.push(new EventsProfiler(options))
   }
 

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

@@ -4,6 +4,9 @@ const { EventEmitter } = require('events')
 const { Config } = require('./config')
 const { snapshotKinds } = require('./constants')
 const { threadNamePrefix } = require('./profilers/shared')
+const dc = require('dc-polyfill')
+
+const profileSubmittedChannel = dc.channel('datadog:profiling:profile-submitted')
 
 function maybeSourceMap (sourceMap, SourceMapper, debug) {
   if (!sourceMap) return
@@ -161,6 +164,7 @@ class Profiler extends EventEmitter {
         this._capture(this._timeoutInterval, endDate)
       }
       await this._submit(encodedProfiles, startDate, endDate, snapshotKind)
+      profileSubmittedChannel.publish()
       this._logger.debug('Submitted profiles')
     } catch (err) {
       this._logger.error(err)

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

@@ -0,0 +1,33 @@
+'use strict'
+
+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
+
+let timerId
+
+module.exports = {
+  start: config => {
+    // Copied from packages/dd-trace/src/profiler.js
+    const flushInterval = coalesce(config.interval, Number(DD_PROFILING_UPLOAD_PERIOD) * 1000, 65 * 1000)
+
+    function scheduleProfileSubmit () {
+      timerId = setTimeout(emitProfileSubmit, flushInterval)
+    }
+
+    function emitProfileSubmit () {
+      profileSubmittedChannel.publish()
+      scheduleProfileSubmit()
+    }
+
+    scheduleProfileSubmit()
+  },
+
+  stop: () => {
+    if (timerId !== undefined) {
+      clearTimeout(timerId)
+      timerId = undefined
+    }
+  }
+}