dd-trace 5.85.0 → 5.86.0

package/packages/dd-trace/src/ci-visibility/telemetry.js

@@ -17,6 +17,22 @@ const formattedTags = {
   isRum: 'is_rum',
   browserDriver: 'browser_driver',
   autoInjected: 'auto_injected',
+  isQuarantined: 'is_quarantined',
+  isDisabled: 'is_disabled',
+  isTestManagementEnabled: 'test_management_enabled',
+  isItrEnabled: 'itr_enabled',
+  isEarlyFlakeDetectionEnabled: 'early_flake_detection_enabled',
+  isFlakyTestRetriesEnabled: 'flaky_test_retries_enabled',
+  isKnownTestsEnabled: 'known_tests_enabled',
+  isImpactedTestsEnabled: 'impacted_tests_enabled',
+  hasFailedTestReplay: 'has_failed_test_replay',
+  isFailedTestReplayEnabled: 'is_failed_test_replay_enabled',
+  // isDiEnabled is specifically for the settings endpoint telemetry
+  isDiEnabled: 'failed_test_replay_enabled',
+  requireGit: 'require_git',
+  isModified: 'is_modified',
+  isRetry: 'is_retry',
+  retryReason: 'retry_reason',
 }
 
 // Transform tags dictionary to array of strings.
@@ -101,6 +117,17 @@ const TELEMETRY_KNOWN_TESTS_MS = 'early_flake_detection.request_ms'
 const TELEMETRY_KNOWN_TESTS_ERRORS = 'early_flake_detection.request_errors'
 const TELEMETRY_KNOWN_TESTS_RESPONSE_TESTS = 'early_flake_detection.response_tests'
 const TELEMETRY_KNOWN_TESTS_RESPONSE_BYTES = 'early_flake_detection.response_bytes'
+// coverage upload
+const TELEMETRY_COVERAGE_UPLOAD = 'coverage_upload.request'
+const TELEMETRY_COVERAGE_UPLOAD_MS = 'coverage_upload.request_ms'
+const TELEMETRY_COVERAGE_UPLOAD_ERRORS = 'coverage_upload.request_errors'
+const TELEMETRY_COVERAGE_UPLOAD_BYTES = 'coverage_upload.request_bytes'
+// test management
+const TELEMETRY_TEST_MANAGEMENT_TESTS = 'test_management_tests.request'
+const TELEMETRY_TEST_MANAGEMENT_TESTS_MS = 'test_management_tests.request_ms'
+const TELEMETRY_TEST_MANAGEMENT_TESTS_ERRORS = 'test_management_tests.request_errors'
+const TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS = 'test_management_tests.response_tests'
+const TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_BYTES = 'test_management_tests.response_bytes'
 
 function isStatusCode400 (statusCode) {
   return statusCode >= 400 && statusCode < 500
@@ -165,4 +192,13 @@ module.exports = {
   TELEMETRY_KNOWN_TESTS_ERRORS,
   TELEMETRY_KNOWN_TESTS_RESPONSE_TESTS,
   TELEMETRY_KNOWN_TESTS_RESPONSE_BYTES,
+  TELEMETRY_COVERAGE_UPLOAD,
+  TELEMETRY_COVERAGE_UPLOAD_MS,
+  TELEMETRY_COVERAGE_UPLOAD_ERRORS,
+  TELEMETRY_COVERAGE_UPLOAD_BYTES,
+  TELEMETRY_TEST_MANAGEMENT_TESTS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_MS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_ERRORS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_BYTES,
 }

package/packages/dd-trace/src/ci-visibility/test-management/get-test-management-tests.js

@@ -5,6 +5,38 @@ const id = require('../../id')
 const { getValueFromEnvSources } = require('../../config/helper')
 const log = require('../../log')
 
+const {
+  incrementCountMetric,
+  distributionMetric,
+  TELEMETRY_TEST_MANAGEMENT_TESTS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_MS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_ERRORS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_BYTES,
+} = require('../telemetry')
+
+// Calculate the number of tests from the test management tests response, which has a shape like:
+// { module: { suites: { suite: { tests: { testName: { properties: {...} } } } } } }
+function getNumFromTestManagementTests (testManagementTests) {
+  if (!testManagementTests) {
+    return 0
+  }
+
+  let totalNumTests = 0
+
+  for (const testModule of Object.values(testManagementTests)) {
+    const { suites } = testModule
+    if (!suites) continue
+    for (const testSuite of Object.values(suites)) {
+      const { tests } = testSuite
+      if (!tests) continue
+      totalNumTests += Object.keys(tests).length
+    }
+  }
+
+  return totalNumTests
+}
+
 function getTestManagementTests ({
   url,
   isEvpProxy,
@@ -58,13 +90,24 @@ function getTestManagementTests ({
 
   log.debug('Requesting test management tests: %s', data)
 
-  request(data, options, (err, res) => {
+  incrementCountMetric(TELEMETRY_TEST_MANAGEMENT_TESTS)
+
+  const startTime = Date.now()
+
+  request(data, options, (err, res, statusCode) => {
+    distributionMetric(TELEMETRY_TEST_MANAGEMENT_TESTS_MS, {}, Date.now() - startTime)
     if (err) {
+      incrementCountMetric(TELEMETRY_TEST_MANAGEMENT_TESTS_ERRORS, { statusCode })
       done(err)
     } else {
       try {
         const { data: { attributes: { modules: testManagementTests } } } = JSON.parse(res)
 
+        const numTests = getNumFromTestManagementTests(testManagementTests)
+
+        distributionMetric(TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS, {}, numTests)
+        distributionMetric(TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_BYTES, {}, res.length)
+
         log.debug('Test management tests received: %j', testManagementTests)
 
         done(null, testManagementTests)

package/packages/dd-trace/src/exporters/common/request.js

@@ -128,50 +128,50 @@ function request (data, options, callback) {
 
     activeRequests++
 
-    const store = storage('legacy').getStore()
-    storage('legacy').enterWith({ noop: true })
-
-    let finished = false
-    const finalize = () => {
-      if (finished) return
-      finished = true
-      activeRequests--
-    }
+    storage('legacy').run({ noop: true }, () => {
+      let finished = false
+      const finalize = () => {
+        if (finished) return
+        finished = true
+        activeRequests--
+      }
 
-    const req = client.request(options, (res) => onResponse(res, finalize))
+      const req = client.request(options, (res) => onResponse(res, finalize))
 
-    req.once('close', finalize)
-    req.once('timeout', finalize)
+      req.once('close', finalize)
+      req.once('timeout', finalize)
 
-    req.once('error', err => {
-      finalize()
-      onError(err)
-    })
+      req.once('error', err => {
+        finalize()
+        onError(err)
+      })
 
-    req.setTimeout(timeout, () => {
-      try {
-        if (typeof req.abort === 'function') {
-          req.abort()
-        } else {
-          req.destroy()
+      req.setTimeout(timeout, () => {
+        try {
+          if (typeof req.abort === 'function') {
+            req.abort()
+          } else {
+            req.destroy()
+          }
+        } catch {
+          // ignore
         }
-      } catch {
-        // ignore
+      })
+
+      if (isReadable) {
+        data.pipe(req) // TODO: Validate whether this is actually retriable.
+      } else {
+        for (const buffer of dataArray) req.write(buffer)
+        req.end()
       }
     })
-
-    if (isReadable) {
-      data.pipe(req) // TODO: Validate whether this is actually retriable.
-    } else {
-      for (const buffer of dataArray) req.write(buffer)
-      req.end()
-    }
-
-    storage('legacy').enterWith(store)
   }
 
-  // TODO: Figure out why setTimeout is needed to avoid losing the async context
-  // in the retry request before socket.connect() is called.
+  // The setTimeout is needed to avoid losing the async context in the retry
+  // request before socket.connect() is called. This is a workaround for the
+  // issue that the AsyncLocalStorage.run() method does not call the
+  // AsyncLocalStorage.enterWith() method when not using AsyncContextFrame.
+  //
   // TODO: Test that this doesn't trace itself on retry when the diagnostics
   // channel events are available in the agent exporter.
   makeRequest(() => setTimeout(() => makeRequest(callback)))

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

@@ -243,5 +243,5 @@ function writeUInt32BE (buffer, value, offset) {
  * @returns {Identifier}
  */
 module.exports = function createIdentifier (value, radix) {
-  return new Identifier(value, radix)
+  return new Identifier(value ?? '', radix)
 }

package/packages/dd-trace/src/lambda/context.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const log = require('../log')
+
+/**
+ * Extracts the context from the given Lambda handler arguments.
+ *
+ * It is possible for users to define a lambda function without specifying a
+ * context arg. In these cases, this function returns null instead of throwing
+ * an error.
+ *
+ * @param {unknown[]} args any amount of arguments
+ * @returns {object | null}
+ */
+exports.extractContext = function extractContext (args) {
+  let context = null
+  for (let i = 0; i < args.length && i < 3; i++) {
+    if (args[i] && typeof args[i].getRemainingTimeInMillis === 'function') {
+      context = args[i]
+      break
+    }
+  }
+  if (!context) {
+    log.debug('Unable to extract context object from Lambda handler arguments')
+  }
+  return context
+}

package/packages/dd-trace/src/lambda/handler.js

@@ -5,6 +5,7 @@ const { channel } = require('../../../datadog-instrumentations/src/helpers/instr
 const { ERROR_MESSAGE, ERROR_TYPE } = require('../constants')
 const { getValueFromEnvSources } = require('../config/helper')
 const { ImpendingTimeout } = require('./runtime/errors')
+const { extractContext } = require('./context')
 
 const globalTracer = global._ddtrace
 const tracer = globalTracer._tracer
@@ -60,23 +61,6 @@ function crashFlush () {
   }
 }
 
-/**
- * Extracts the context from the given Lambda handler arguments.
- *
- * @param {unknown[]} args any amount of arguments
- * @returns the context, if extraction was succesful.
- */
-function extractContext (args) {
-  let context = args.length > 1 ? args[1] : undefined
-  if (context === undefined || context.getRemainingTimeInMillis === undefined) {
-    context = args.length > 2 ? args[2] : undefined
-    if (context === undefined || context.getRemainingTimeInMillis === undefined) {
-      throw new Error('Could not extract context')
-    }
-  }
-  return context
-}
-
 /**
  * Patches your AWS Lambda handler function to add some tracing support.
  *
@@ -86,7 +70,10 @@ exports.datadog = function datadog (lambdaHandler) {
   return (...args) => {
     const context = extractContext(args)
 
-    checkTimeout(context)
+    if (context) {
+      checkTimeout(context)
+    }
+
     const result = lambdaHandler.apply(this, args)
     if (result && typeof result.then === 'function') {
       return result.then((res) => {

package/packages/dd-trace/src/log/writer.js

@@ -14,11 +14,7 @@ let logger = defaultLogger
 let logChannel = new LogChannel()
 
 function withNoop (fn) {
-  const store = storage('legacy').getStore()
-
-  storage('legacy').enterWith({ noop: true })
-  fn()
-  storage('legacy').enterWith(store)
+  storage('legacy').run({ noop: true }, fn)
 }
 
 function unsubscribeAll () {

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

@@ -64,6 +64,14 @@ const {
   getModifiedFilesFromDiff,
   getPullRequestBaseBranch,
   TEST_IS_TEST_FRAMEWORK_WORKER,
+  TEST_IS_NEW,
+  TEST_IS_RUM_ACTIVE,
+  TEST_BROWSER_DRIVER,
+  TEST_MANAGEMENT_IS_QUARANTINED,
+  TEST_MANAGEMENT_IS_DISABLED,
+  TEST_IS_MODIFIED,
+  TEST_IS_RETRY,
+  TEST_RETRY_REASON,
 } = require('./util/test')
 
 const FRAMEWORK_TO_TRIMMED_COMMAND = {
@@ -354,12 +362,50 @@ module.exports = class CiPlugin extends Plugin {
 
   get telemetry () {
     const testFramework = this.constructor.id
+    const exporter = this.tracer?._exporter
+    // TODO: only jest worker supported yet
+    const isSupportedWorker = exporter && typeof exporter.exportTelemetry === 'function'
+    const ciProviderName = this.ciProviderName
+
+    if (isSupportedWorker) {
+      // In supported worker: send telemetry events to main process
+      return {
+        ciVisEvent: function (name, testLevel, tags = {}) {
+          exporter.exportTelemetry({
+            type: 'ciVisEvent',
+            name,
+            testLevel,
+            testFramework,
+            isUnsupportedCIProvider: !ciProviderName,
+            tags,
+          })
+        },
+        count: function (name, tags, value = 1) {
+          exporter.exportTelemetry({
+            type: 'count',
+            name,
+            tags,
+            value,
+          })
+        },
+        distribution: function (name, tags, measure) {
+          exporter.exportTelemetry({
+            type: 'distribution',
+            name,
+            tags,
+            measure,
+          })
+        },
+      }
+    }
+
+    // In main process or unsupported worker: execute telemetry directly
     return {
       ciVisEvent: function (name, testLevel, tags = {}) {
         incrementCountMetric(name, {
           testLevel,
           testFramework,
-          isUnsupportedCIProvider: !this.ciProviderName,
+          isUnsupportedCIProvider: !ciProviderName,
           ...tags,
         })
       },
@@ -669,4 +715,20 @@ module.exports = class CiPlugin extends Plugin {
 
     uploadNextReport()
   }
+
+  getTestTelemetryTags (testSpan) {
+    const activeSpanTags = testSpan.context()._tags
+    return {
+      hasCodeOwners: !!activeSpanTags[TEST_CODE_OWNERS] || undefined,
+      isNew: activeSpanTags[TEST_IS_NEW] === 'true' || undefined,
+      isRum: activeSpanTags[TEST_IS_RUM_ACTIVE] === 'true' || undefined,
+      browserDriver: activeSpanTags[TEST_BROWSER_DRIVER],
+      isQuarantined: activeSpanTags[TEST_MANAGEMENT_IS_QUARANTINED] === 'true' || undefined,
+      isDisabled: activeSpanTags[TEST_MANAGEMENT_IS_DISABLED] === 'true' || undefined,
+      isModified: activeSpanTags[TEST_IS_MODIFIED] === 'true' || undefined,
+      isRetry: activeSpanTags[TEST_IS_RETRY] === 'true' || undefined,
+      retryReason: activeSpanTags[TEST_RETRY_REASON],
+      isFailedTestReplayEnabled: activeSpanTags[DI_ERROR_DEBUG_INFO_CAPTURED] === 'true' || undefined,
+    }
+  }
 }

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

@@ -47,40 +47,37 @@ function sanitizedExec (
   errorMetric,
   shouldTrim = true
 ) {
-  const store = storage('legacy').getStore()
-  storage('legacy').enterWith({ noop: true })
-
-  let startTime
-  if (operationMetric) {
-    incrementCountMetric(operationMetric.name, operationMetric.tags)
-  }
-  if (durationMetric) {
-    startTime = Date.now()
-  }
-  try {
-    let result = cachedExec(cmd, flags, { stdio: 'pipe' }).toString()
-
-    if (shouldTrim) {
-      result = result.replaceAll(/(\r\n|\n|\r)/gm, '')
+  return storage('legacy').run({ noop: true }, () => {
+    let startTime
+    if (operationMetric) {
+      incrementCountMetric(operationMetric.name, operationMetric.tags)
     }
-
     if (durationMetric) {
-      distributionMetric(durationMetric.name, durationMetric.tags, Date.now() - startTime)
+      startTime = Date.now()
     }
-    return result
-  } catch (err) {
-    if (errorMetric) {
-      incrementCountMetric(errorMetric.name, {
-        ...errorMetric.tags,
-        errorType: err.code,
-        exitCode: err.status || err.errno,
-      })
+    try {
+      let result = cachedExec(cmd, flags, { stdio: 'pipe' }).toString()
+
+      if (shouldTrim) {
+        result = result.replaceAll(/(\r\n|\n|\r)/gm, '')
+      }
+
+      if (durationMetric) {
+        distributionMetric(durationMetric.name, durationMetric.tags, Date.now() - startTime)
+      }
+      return result
+    } catch (err) {
+      if (errorMetric) {
+        incrementCountMetric(errorMetric.name, {
+          ...errorMetric.tags,
+          errorType: err.code,
+          exitCode: err.status || err.errno,
+        })
+      }
+      log.error('Git plugin error executing command', err)
+      return ''
     }
-    log.error('Git plugin error executing command', err)
-    return ''
-  } finally {
-    storage('legacy').enterWith(store)
-  }
+  })
 }
 
 function isDirectory (path) {

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

@@ -119,6 +119,7 @@ const TEST_BROWSER_VERSION = 'test.browser.version'
 const JEST_WORKER_TRACE_PAYLOAD_CODE = 60
 const JEST_WORKER_COVERAGE_PAYLOAD_CODE = 61
 const JEST_WORKER_LOGS_PAYLOAD_CODE = 62
+const JEST_WORKER_TELEMETRY_PAYLOAD_CODE = 63
 
 // cucumber worker variables
 const CUCUMBER_WORKER_TRACE_PAYLOAD_CODE = 70
@@ -225,6 +226,7 @@ module.exports = {
   JEST_WORKER_TRACE_PAYLOAD_CODE,
   JEST_WORKER_COVERAGE_PAYLOAD_CODE,
   JEST_WORKER_LOGS_PAYLOAD_CODE,
+  JEST_WORKER_TELEMETRY_PAYLOAD_CODE,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
   MOCHA_WORKER_TRACE_PAYLOAD_CODE,
   PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE,
@@ -573,7 +575,7 @@ function getTestSuitePath (testSuiteAbsolutePath, sourceRoot) {
     ? testSuiteAbsolutePath
     : path.relative(sourceRoot, testSuiteAbsolutePath)
 
-  return testSuitePath.replace(path.sep, '/')
+  return testSuitePath.replaceAll(path.sep, '/')
 }
 
 const POSSIBLE_CODEOWNERS_LOCATIONS = [

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

@@ -54,6 +54,7 @@ function startSpanHelper (tracer, name, options, traceCtx, config = {}) {
 
 const web = {
   TYPE: WEB,
+  /** @type {TracingPlugin | null} */
   plugin: null,
 
   // Ensure the configuration has the correct structure and defaults.

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

@@ -1,8 +1,8 @@
 'use strict'
 
-const os = require('os')
 const path = require('path')
 const { pathToFileURL } = require('url')
+
 const satisfies = require('../../../../vendor/dist/semifies')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const { getIsAzureFunction } = require('../serverless')
@@ -10,6 +10,8 @@ const { isFalse, isTrue } = require('../util')
 const { getAzureTagsFromMetadata, getAzureAppMetadata, getAzureFunctionMetadata } = require('../azure_metadata')
 const { getEnvironmentVariable, getValueFromEnvSources } = require('../config/helper')
 const { getAgentUrl } = require('../agent/url')
+const { isACFActive } = require('../../../datadog-core/src/storage')
+
 const { AgentExporter } = require('./exporters/agent')
 const { FileExporter } = require('./exporters/file')
 const { ConsoleLogger } = require('./loggers/console')
@@ -18,12 +20,12 @@ const SpaceProfiler = require('./profilers/space')
 const EventsProfiler = require('./profilers/events')
 const { oomExportStrategies, snapshotKinds } = require('./constants')
 const { tagger } = require('./tagger')
+
 class Config {
   constructor (options = {}) {
     // TODO: Remove entries that were already resolved in config.
     // For the others, move them over to config.
     const AWS_LAMBDA_FUNCTION_NAME = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME')
-    const NODE_OPTIONS = getEnvironmentVariable('NODE_OPTIONS')
 
     // TODO: Move initialization of these values to packages/dd-trace/src/config/index.js, and just read from config
     const {
@@ -50,7 +52,6 @@ class Config {
       DD_TAGS,
     } = getProfilingEnvValues()
 
-    const host = os.hostname()
     // Must be longer than one minute so pad with five seconds
     const flushInterval = options.interval ?? (Number(DD_PROFILING_UPLOAD_PERIOD) * 1000 || 65 * 1000)
     const uploadTimeout = options.uploadTimeout ?? (Number(DD_PROFILING_UPLOAD_TIMEOUT) || 60 * 1000)
@@ -59,7 +60,6 @@ class Config {
     // TODO: Remove the fallback. Just use the value from the config.
     this.service = options.service || 'node'
     this.env = options.env
-    this.host = host
     this.functionname = AWS_LAMBDA_FUNCTION_NAME
 
     this.version = options.version
@@ -68,7 +68,7 @@ class Config {
       tagger.parse(options.tags),
       tagger.parse({
         env: options.env,
-        host,
+        host: options.reportHostname ? require('os').hostname() : undefined,
         service: this.service,
         version: this.version,
         functionname: AWS_LAMBDA_FUNCTION_NAME,
@@ -219,16 +219,8 @@ class Config {
       that.asyncContextFrameEnabled = false
     }
 
-    const hasExecArg = (arg) => process.execArgv.includes(arg) || String(NODE_OPTIONS).includes(arg)
+    const canUseAsyncContextFrame = samplingContextsAvailable && isACFActive
 
-    let canUseAsyncContextFrame = false
-    if (samplingContextsAvailable) {
-      if (isAtLeast24) {
-        canUseAsyncContextFrame = !hasExecArg('--no-async-context-frame')
-      } else if (satisfies(process.versions.node, '>=22.9.0')) {
-        canUseAsyncContextFrame = hasExecArg('--experimental-async-context-frame')
-      }
-    }
     this.asyncContextFrameEnabled = isTrue(DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED ?? canUseAsyncContextFrame)
     if (this.asyncContextFrameEnabled && !canUseAsyncContextFrame) {
       if (!samplingContextsAvailable) {

package/packages/dd-trace/src/profiling/exporters/agent.js

@@ -38,32 +38,31 @@ function countStatusCode (statusCode) {
 function sendRequest (options, form, callback) {
   const request = options.protocol === 'https:' ? httpsRequest : httpRequest
 
-  const store = storage('legacy').getStore()
-  storage('legacy').enterWith({ noop: true })
-  requestCounter.inc()
-  const start = perf.now()
-  const req = request(options, res => {
-    durationDistribution.track(perf.now() - start)
-    countStatusCode(res.statusCode)
-    if (res.statusCode >= 400) {
-      statusCodeErrorCounter.inc()
-      const error = new Error(`HTTP Error ${res.statusCode}`)
-      error.status = res.statusCode
-      callback(error)
-    } else {
-      callback(null, res)
-    }
-  })
+  storage('legacy').run({ noop: true }, () => {
+    requestCounter.inc()
+    const start = perf.now()
+    const req = request(options, res => {
+      durationDistribution.track(perf.now() - start)
+      countStatusCode(res.statusCode)
+      if (res.statusCode >= 400) {
+        statusCodeErrorCounter.inc()
+        const error = new Error(`HTTP Error ${res.statusCode}`)
+        error.status = res.statusCode
+        callback(error)
+      } else {
+        callback(null, res)
+      }
+    })
 
-  req.on('error', (err) => {
-    networkErrorCounter.inc()
-    callback(err)
+    req.on('error', (err) => {
+      networkErrorCounter.inc()
+      callback(err)
+    })
+    if (form) {
+      sizeDistribution.track(form.size())
+      form.pipe(req)
+    }
   })
-  if (form) {
-    sizeDistribution.track(form.size())
-    form.pipe(req)
-  }
-  storage('legacy').enterWith(store)
 }
 
 function getBody (stream, callback) {

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

@@ -76,6 +76,7 @@ class Profiler extends EventEmitter {
       repositoryUrl,
       commitSHA,
       injectionEnabled,
+      reportHostname,
     } = config
     const { enabled, sourceMap, exporters } = config.profiling
     const { heartbeatInterval } = config.telemetry
@@ -112,6 +113,7 @@ class Profiler extends EventEmitter {
       libraryInjected,
       activation,
       heartbeatInterval,
+      reportHostname,
     }
 
     return this._start(options).catch((err) => {

package/packages/dd-trace/src/startup-log.js

@@ -75,6 +75,7 @@ function tracerInfo () {
     profiling_enabled: config.profiling?.enabled === 'true' || config.profiling?.enabled === 'auto',
     integrations_loaded: Object.keys(pluginManager._pluginsByName),
     appsec_enabled: !!config.appsec.enabled,
+    data_streams_enabled: !!config.dsmEnabled,
   }
 
   return out