dd-trace 5.24.0 → 5.25.0

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

@@ -0,0 +1,90 @@
+'use strict'
+
+const { workerData: { breakpointSetChannel, breakpointHitChannel } } = require('worker_threads')
+// TODO: move debugger/devtools_client/session to common place
+const session = require('../../../debugger/devtools_client/session')
+// TODO: move debugger/devtools_client/snapshot to common place
+const { getLocalStateForCallFrame } = require('../../../debugger/devtools_client/snapshot')
+// TODO: move debugger/devtools_client/state to common place
+const {
+  findScriptFromPartialPath,
+  getStackFromCallFrames
+} = require('../../../debugger/devtools_client/state')
+const log = require('../../../log')
+
+let sessionStarted = false
+
+const breakpointIdToSnapshotId = new Map()
+const breakpointIdToProbe = new Map()
+
+session.on('Debugger.paused', async ({ params: { hitBreakpoints: [hitBreakpoint], callFrames } }) => {
+  const probe = breakpointIdToProbe.get(hitBreakpoint)
+  if (!probe) {
+    log.warn(`No probe found for breakpoint ${hitBreakpoint}`)
+    return session.post('Debugger.resume')
+  }
+
+  const stack = getStackFromCallFrames(callFrames)
+
+  const getLocalState = await getLocalStateForCallFrame(callFrames[0])
+
+  await session.post('Debugger.resume')
+
+  const snapshotId = breakpointIdToSnapshotId.get(hitBreakpoint)
+
+  const snapshot = {
+    id: snapshotId,
+    timestamp: Date.now(),
+    probe: {
+      id: probe.probeId,
+      version: '0',
+      location: probe.location
+    },
+    stack,
+    language: 'javascript'
+  }
+
+  const state = getLocalState()
+  if (state) {
+    snapshot.captures = {
+      lines: { [probe.location.lines[0]]: { locals: state } }
+    }
+  }
+
+  breakpointHitChannel.postMessage({ snapshot })
+})
+
+// TODO: add option to remove breakpoint
+breakpointSetChannel.on('message', async ({ snapshotId, probe: { id: probeId, file, line } }) => {
+  await addBreakpoint(snapshotId, { probeId, file, line })
+  breakpointSetChannel.postMessage({ probeId })
+})
+
+async function addBreakpoint (snapshotId, probe) {
+  if (!sessionStarted) await start()
+  const { file, line } = probe
+
+  probe.location = { file, lines: [String(line)] }
+
+  const script = findScriptFromPartialPath(file)
+  if (!script) throw new Error(`No loaded script found for ${file}`)
+
+  const [path, scriptId] = script
+
+  log.debug(`Adding breakpoint at ${path}:${line}`)
+
+  const { breakpointId } = await session.post('Debugger.setBreakpoint', {
+    location: {
+      scriptId,
+      lineNumber: line - 1
+    }
+  })
+
+  breakpointIdToProbe.set(breakpointId, probe)
+  breakpointIdToSnapshotId.set(breakpointId, snapshotId)
+}
+
+function start () {
+  sessionStarted = true
+  return session.post('Debugger.enable') // return instead of await to reduce number of promises created
+}

package/packages/dd-trace/src/ci-visibility/exporters/agent-proxy/index.js

@@ -7,6 +7,7 @@ const CiVisibilityExporter = require('../ci-visibility-exporter')
 
 const AGENT_EVP_PROXY_PATH_PREFIX = '/evp_proxy/v'
 const AGENT_EVP_PROXY_PATH_REGEX = /\/evp_proxy\/v(\d+)\/?/
+const AGENT_DEBUGGER_INPUT = '/debugger/v1/input'
 
 function getLatestEvpProxyVersion (err, agentInfo) {
   if (err) {
@@ -24,6 +25,10 @@ function getLatestEvpProxyVersion (err, agentInfo) {
   }, 0)
 }
 
+function getCanForwardDebuggerLogs (err, agentInfo) {
+  return !err && agentInfo.endpoints.some(endpoint => endpoint === AGENT_DEBUGGER_INPUT)
+}
+
 class AgentProxyCiVisibilityExporter extends CiVisibilityExporter {
   constructor (config) {
     super(config)
@@ -33,7 +38,8 @@ class AgentProxyCiVisibilityExporter extends CiVisibilityExporter {
       prioritySampler,
       lookup,
       protocolVersion,
-      headers
+      headers,
+      isTestDynamicInstrumentationEnabled
     } = config
 
     this.getAgentInfo((err, agentInfo) => {
@@ -60,6 +66,18 @@ class AgentProxyCiVisibilityExporter extends CiVisibilityExporter {
           url: this._url,
           evpProxyPrefix
         })
+        if (isTestDynamicInstrumentationEnabled) {
+          const canFowardLogs = getCanForwardDebuggerLogs(err, agentInfo)
+          if (canFowardLogs) {
+            const DynamicInstrumentationLogsWriter = require('../agentless/di-logs-writer')
+            this._logsWriter = new DynamicInstrumentationLogsWriter({
+              url: this._url,
+              tags,
+              isAgentProxy: true
+            })
+            this._canForwardLogs = true
+          }
+        }
       } else {
         this._writer = new AgentWriter({
           url: this._url,

package/packages/dd-trace/src/ci-visibility/exporters/agentless/di-logs-writer.js

@@ -0,0 +1,53 @@
+'use strict'
+const request = require('../../../exporters/common/request')
+const log = require('../../../log')
+const { safeJSONStringify } = require('../../../exporters/common/util')
+const { JSONEncoder } = require('../../encode/json-encoder')
+
+const BaseWriter = require('../../../exporters/common/writer')
+
+// Writer used by the integration between Dynamic Instrumentation and Test Visibility
+// It is used to encode and send logs to both the logs intake directly and the
+// `/debugger/v1/input` endpoint in the agent, which is a proxy to the logs intake.
+class DynamicInstrumentationLogsWriter extends BaseWriter {
+  constructor ({ url, timeout, isAgentProxy = false }) {
+    super(...arguments)
+    this._url = url
+    this._encoder = new JSONEncoder()
+    this._isAgentProxy = isAgentProxy
+    this.timeout = timeout
+  }
+
+  _sendPayload (data, _, done) {
+    const options = {
+      path: '/api/v2/logs',
+      method: 'POST',
+      headers: {
+        'dd-api-key': process.env.DATADOG_API_KEY || process.env.DD_API_KEY,
+        'Content-Type': 'application/json'
+      },
+      // TODO: what's a good value for timeout for the logs intake?
+      timeout: this.timeout || 15000,
+      url: this._url
+    }
+
+    if (this._isAgentProxy) {
+      delete options.headers['dd-api-key']
+      options.path = '/debugger/v1/input'
+    }
+
+    log.debug(() => `Request to the logs intake: ${safeJSONStringify(options)}`)
+
+    request(data, options, (err, res) => {
+      if (err) {
+        log.error(err)
+        done()
+        return
+      }
+      log.debug(`Response from the logs intake: ${res}`)
+      done()
+    })
+  }
+}
+
+module.exports = DynamicInstrumentationLogsWriter

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

@@ -9,10 +9,11 @@ const log = require('../../../log')
 class AgentlessCiVisibilityExporter extends CiVisibilityExporter {
   constructor (config) {
     super(config)
-    const { tags, site, url } = config
+    const { tags, site, url, isTestDynamicInstrumentationEnabled } = config
     // we don't need to request /info because we are using agentless by configuration
     this._isInitialized = true
     this._resolveCanUseCiVisProtocol(true)
+    this._canForwardLogs = true
 
     this._url = url || new URL(`https://citestcycle-intake.${site}`)
     this._writer = new Writer({ url: this._url, tags })
@@ -20,6 +21,12 @@ class AgentlessCiVisibilityExporter extends CiVisibilityExporter {
     this._coverageUrl = url || new URL(`https://citestcov-intake.${site}`)
     this._coverageWriter = new CoverageWriter({ url: this._coverageUrl })
 
+    if (isTestDynamicInstrumentationEnabled) {
+      const DynamicInstrumentationLogsWriter = require('./di-logs-writer')
+      this._logsUrl = url || new URL(`https://http-intake.logs.${site}`)
+      this._logsWriter = new DynamicInstrumentationLogsWriter({ url: this._logsUrl, tags })
+    }
+
     this._apiUrl = url || new URL(`https://api.${site}`)
     // Agentless is always gzip compatible
     this._isGzipCompatible = true

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

@@ -8,6 +8,7 @@ const { getSkippableSuites: getSkippableSuitesRequest } = require('../intelligen
 const { getKnownTests: getKnownTestsRequest } = require('../early-flake-detection/get-known-tests')
 const log = require('../../log')
 const AgentInfoExporter = require('../../exporters/common/agent-info-exporter')
+const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../../plugins/util/tags')
 
 function getTestConfigurationTags (tags) {
   if (!tags) {
@@ -36,6 +37,7 @@ class CiVisibilityExporter extends AgentInfoExporter {
     super(config)
     this._timer = undefined
     this._coverageTimer = undefined
+    this._logsTimer = undefined
     this._coverageBuffer = []
     // The library can use new features like ITR and test suite level visibility
     // AKA CI Vis Protocol
@@ -255,6 +257,47 @@ class CiVisibilityExporter extends AgentInfoExporter {
     this._export(formattedCoverage, this._coverageWriter, '_coverageTimer')
   }
 
+  formatLogMessage (testConfiguration, logMessage) {
+    const {
+      [GIT_REPOSITORY_URL]: gitRepositoryUrl,
+      [GIT_COMMIT_SHA]: gitCommitSha
+    } = testConfiguration
+
+    const { service, env, version } = this._config
+
+    return {
+      ddtags: [
+        ...(logMessage.ddtags || []),
+        `${GIT_REPOSITORY_URL}:${gitRepositoryUrl}`,
+        `${GIT_COMMIT_SHA}:${gitCommitSha}`
+      ].join(','),
+      level: 'error',
+      service,
+      dd: {
+        ...(logMessage.dd || []),
+        service,
+        env,
+        version
+      },
+      ddsource: 'dd_debugger',
+      ...logMessage
+    }
+  }
+
+  // DI logs
+  exportDiLogs (testConfiguration, logMessage) {
+    // TODO: could we lose logs if it's not initialized?
+    if (!this._config.isTestDynamicInstrumentationEnabled || !this._isInitialized || !this._canForwardLogs) {
+      return
+    }
+
+    this._export(
+      this.formatLogMessage(testConfiguration, logMessage),
+      this._logsWriter,
+      '_logsTimer'
+    )
+  }
+
   flush (done = () => {}) {
     if (!this._isInitialized) {
       return done()

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

@@ -17,7 +17,7 @@ const { getGitMetadataFromGitProperties, removeUserSensitiveInfo } = require('./
 const { updateConfig } = require('./telemetry')
 const telemetryMetrics = require('./telemetry/metrics')
 const { getIsGCPFunction, getIsAzureFunction } = require('./serverless')
-const { ORIGIN_KEY } = require('./constants')
+const { ORIGIN_KEY, GRPC_CLIENT_ERROR_STATUSES, GRPC_SERVER_ERROR_STATUSES } = require('./constants')
 const { appendRules } = require('./payload-tagging/config')
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
@@ -462,6 +462,9 @@ class Config {
     this._setValue(defaults, 'appsec.stackTrace.maxDepth', 32)
     this._setValue(defaults, 'appsec.stackTrace.maxStackTraces', 2)
     this._setValue(defaults, 'appsec.wafTimeout', 5e3) // µs
+    this._setValue(defaults, 'baggageMaxBytes', 8192)
+    this._setValue(defaults, 'baggageMaxItems', 64)
+    this._setValue(defaults, 'ciVisibilityTestSessionName', '')
     this._setValue(defaults, 'clientIpEnabled', false)
     this._setValue(defaults, 'clientIpHeader', null)
     this._setValue(defaults, 'codeOriginForSpans.enabled', false)
@@ -477,6 +480,8 @@ class Config {
     this._setValue(defaults, 'flushInterval', 2000)
     this._setValue(defaults, 'flushMinSpans', 1000)
     this._setValue(defaults, 'gitMetadataEnabled', true)
+    this._setValue(defaults, 'grpc.client.error.statuses', GRPC_CLIENT_ERROR_STATUSES)
+    this._setValue(defaults, 'grpc.server.error.statuses', GRPC_SERVER_ERROR_STATUSES)
     this._setValue(defaults, 'headerTags', [])
     this._setValue(defaults, 'hostname', '127.0.0.1')
     this._setValue(defaults, 'iast.cookieFilterPattern', '.{32,}')
@@ -499,8 +504,13 @@ class Config {
     this._setValue(defaults, 'isGitUploadEnabled', false)
     this._setValue(defaults, 'isIntelligentTestRunnerEnabled', false)
     this._setValue(defaults, 'isManualApiEnabled', false)
+    this._setValue(defaults, 'llmobs.agentlessEnabled', false)
+    this._setValue(defaults, 'llmobs.enabled', false)
+    this._setValue(defaults, 'llmobs.mlApp', undefined)
     this._setValue(defaults, 'ciVisibilityTestSessionName', '')
     this._setValue(defaults, 'ciVisAgentlessLogSubmissionEnabled', false)
+    this._setValue(defaults, 'legacyBaggageEnabled', true)
+    this._setValue(defaults, 'isTestDynamicInstrumentationEnabled', false)
     this._setValue(defaults, 'logInjection', false)
     this._setValue(defaults, 'lookup', undefined)
     this._setValue(defaults, 'memcachedCommandEnabled', false)
@@ -520,7 +530,7 @@ class Config {
     this._setValue(defaults, 'reportHostname', false)
     this._setValue(defaults, 'runtimeMetrics', false)
     this._setValue(defaults, 'sampleRate', undefined)
-    this._setValue(defaults, 'sampler.rateLimit', undefined)
+    this._setValue(defaults, 'sampler.rateLimit', 100)
     this._setValue(defaults, 'sampler.rules', [])
     this._setValue(defaults, 'sampler.spanSamplingRules', [])
     this._setValue(defaults, 'scope', undefined)
@@ -541,11 +551,12 @@ class Config {
     this._setValue(defaults, 'telemetry.heartbeatInterval', 60000)
     this._setValue(defaults, 'telemetry.logCollection', false)
     this._setValue(defaults, 'telemetry.metrics', true)
+    this._setValue(defaults, 'traceEnabled', true)
     this._setValue(defaults, 'traceId128BitGenerationEnabled', true)
     this._setValue(defaults, 'traceId128BitLoggingEnabled', false)
     this._setValue(defaults, 'tracePropagationExtractFirst', false)
-    this._setValue(defaults, 'tracePropagationStyle.inject', ['datadog', 'tracecontext'])
-    this._setValue(defaults, 'tracePropagationStyle.extract', ['datadog', 'tracecontext'])
+    this._setValue(defaults, 'tracePropagationStyle.inject', ['datadog', 'tracecontext', 'baggage'])
+    this._setValue(defaults, 'tracePropagationStyle.extract', ['datadog', 'tracecontext', 'baggage'])
     this._setValue(defaults, 'tracePropagationStyle.otelPropagators', false)
     this._setValue(defaults, 'tracing', true)
     this._setValue(defaults, 'url', undefined)
@@ -584,6 +595,8 @@ class Config {
       DD_EXPERIMENTAL_API_SECURITY_ENABLED,
       DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED,
       DD_EXPERIMENTAL_PROFILING_ENABLED,
+      DD_GRPC_CLIENT_ERROR_STATUSES,
+      DD_GRPC_SERVER_ERROR_STATUSES,
       JEST_WORKER_ID,
       DD_IAST_COOKIE_FILTER_PATTERN,
       DD_IAST_DEDUPLICATION_ENABLED,
@@ -599,6 +612,9 @@ class Config {
       DD_INSTRUMENTATION_TELEMETRY_ENABLED,
       DD_INSTRUMENTATION_CONFIG_ID,
       DD_LOGS_INJECTION,
+      DD_LLMOBS_AGENTLESS_ENABLED,
+      DD_LLMOBS_ENABLED,
+      DD_LLMOBS_ML_APP,
       DD_OPENAI_LOGS_ENABLED,
       DD_OPENAI_SPAN_CHAR_LIMIT,
       DD_PROFILING_ENABLED,
@@ -625,14 +641,18 @@ class Config {
       DD_TRACE_AGENT_HOSTNAME,
       DD_TRACE_AGENT_PORT,
       DD_TRACE_AGENT_PROTOCOL_VERSION,
+      DD_TRACE_BAGGAGE_MAX_BYTES,
+      DD_TRACE_BAGGAGE_MAX_ITEMS,
       DD_TRACE_CLIENT_IP_ENABLED,
       DD_TRACE_CLIENT_IP_HEADER,
+      DD_TRACE_ENABLED,
       DD_TRACE_EXPERIMENTAL_EXPORTER,
       DD_TRACE_EXPERIMENTAL_GET_RUM_DATA_ENABLED,
       DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED,
       DD_TRACE_GIT_METADATA_ENABLED,
       DD_TRACE_GLOBAL_TAGS,
       DD_TRACE_HEADER_TAGS,
+      DD_TRACE_LEGACY_BAGGAGE_ENABLED,
       DD_TRACE_MEMCACHED_COMMAND_ENABLED,
       DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP,
       DD_TRACE_PARTIAL_FLUSH_MIN_SPANS,
@@ -704,6 +724,8 @@ class Config {
     this._envUnprocessed['appsec.stackTrace.maxStackTraces'] = DD_APPSEC_MAX_STACK_TRACES
     this._setValue(env, 'appsec.wafTimeout', maybeInt(DD_APPSEC_WAF_TIMEOUT))
     this._envUnprocessed['appsec.wafTimeout'] = DD_APPSEC_WAF_TIMEOUT
+    this._setValue(env, 'baggageMaxBytes', DD_TRACE_BAGGAGE_MAX_BYTES)
+    this._setValue(env, 'baggageMaxItems', DD_TRACE_BAGGAGE_MAX_ITEMS)
     this._setBoolean(env, 'clientIpEnabled', DD_TRACE_CLIENT_IP_ENABLED)
     this._setString(env, 'clientIpHeader', DD_TRACE_CLIENT_IP_HEADER)
     this._setBoolean(env, 'codeOriginForSpans.enabled', DD_CODE_ORIGIN_FOR_SPANS_ENABLED)
@@ -713,6 +735,7 @@ class Config {
     this._setBoolean(env, 'dsmEnabled', DD_DATA_STREAMS_ENABLED)
     this._setBoolean(env, 'dynamicInstrumentationEnabled', DD_DYNAMIC_INSTRUMENTATION_ENABLED)
     this._setString(env, 'env', DD_ENV || tags.env)
+    this._setBoolean(env, 'traceEnabled', DD_TRACE_ENABLED)
     this._setBoolean(env, 'experimental.enableGetRumData', DD_TRACE_EXPERIMENTAL_GET_RUM_DATA_ENABLED)
     this._setString(env, 'experimental.exporter', DD_TRACE_EXPERIMENTAL_EXPORTER)
     this._setBoolean(env, 'experimental.runtimeId', DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED)
@@ -720,6 +743,8 @@ class Config {
     this._setValue(env, 'flushMinSpans', maybeInt(DD_TRACE_PARTIAL_FLUSH_MIN_SPANS))
     this._envUnprocessed.flushMinSpans = DD_TRACE_PARTIAL_FLUSH_MIN_SPANS
     this._setBoolean(env, 'gitMetadataEnabled', DD_TRACE_GIT_METADATA_ENABLED)
+    this._setIntegerRangeSet(env, 'grpc.client.error.statuses', DD_GRPC_CLIENT_ERROR_STATUSES)
+    this._setIntegerRangeSet(env, 'grpc.server.error.statuses', DD_GRPC_SERVER_ERROR_STATUSES)
     this._setArray(env, 'headerTags', DD_TRACE_HEADER_TAGS)
     this._setString(env, 'hostname', coalesce(DD_AGENT_HOST, DD_TRACE_AGENT_HOSTNAME))
     this._setString(env, 'iast.cookieFilterPattern', DD_IAST_COOKIE_FILTER_PATTERN)
@@ -741,6 +766,10 @@ class Config {
     this._setArray(env, 'injectionEnabled', DD_INJECTION_ENABLED)
     this._setBoolean(env, 'isAzureFunction', getIsAzureFunction())
     this._setBoolean(env, 'isGCPFunction', getIsGCPFunction())
+    this._setBoolean(env, 'legacyBaggageEnabled', DD_TRACE_LEGACY_BAGGAGE_ENABLED)
+    this._setBoolean(env, 'llmobs.agentlessEnabled', DD_LLMOBS_AGENTLESS_ENABLED)
+    this._setBoolean(env, 'llmobs.enabled', DD_LLMOBS_ENABLED)
+    this._setString(env, 'llmobs.mlApp', DD_LLMOBS_ML_APP)
     this._setBoolean(env, 'logInjection', DD_LOGS_INJECTION)
     // Requires an accompanying DD_APM_OBFUSCATION_MEMCACHED_KEEP_COMMAND=true in the agent
     this._setBoolean(env, 'memcachedCommandEnabled', DD_TRACE_MEMCACHED_COMMAND_ENABLED)
@@ -874,6 +903,8 @@ class Config {
     this._optsUnprocessed['appsec.wafTimeout'] = options.appsec.wafTimeout
     this._setBoolean(opts, 'clientIpEnabled', options.clientIpEnabled)
     this._setString(opts, 'clientIpHeader', options.clientIpHeader)
+    this._setValue(opts, 'baggageMaxBytes', options.baggageMaxBytes)
+    this._setValue(opts, 'baggageMaxItems', options.baggageMaxItems)
     this._setBoolean(opts, 'codeOriginForSpans.enabled', options.codeOriginForSpans?.enabled)
     this._setString(opts, 'dbmPropagationMode', options.dbmPropagationMode)
     if (options.dogstatsd) {
@@ -911,6 +942,9 @@ class Config {
     }
     this._setString(opts, 'iast.telemetryVerbosity', options.iast && options.iast.telemetryVerbosity)
     this._setBoolean(opts, 'isCiVisibility', options.isCiVisibility)
+    this._setBoolean(opts, 'legacyBaggageEnabled', options.legacyBaggageEnabled)
+    this._setBoolean(opts, 'llmobs.agentlessEnabled', options.llmobs?.agentlessEnabled)
+    this._setString(opts, 'llmobs.mlApp', options.llmobs?.mlApp)
     this._setBoolean(opts, 'logInjection', options.logInjection)
     this._setString(opts, 'lookup', options.lookup)
     this._setBoolean(opts, 'openAiLogsEnabled', options.openAiLogsEnabled)
@@ -946,6 +980,15 @@ class Config {
     this._setBoolean(opts, 'traceId128BitGenerationEnabled', options.traceId128BitGenerationEnabled)
     this._setBoolean(opts, 'traceId128BitLoggingEnabled', options.traceId128BitLoggingEnabled)
     this._setString(opts, 'version', options.version || tags.version)
+
+    // For LLMObs, we want the environment variable to take precedence over the options.
+    // This is reliant on environment config being set before options.
+    // This is to make sure the origins of each value are tracked appropriately for telemetry.
+    // We'll only set `llmobs.enabled` on the opts when it's not set on the environment, and options.llmobs is provided.
+    const llmobsEnabledEnv = this._env['llmobs.enabled']
+    if (llmobsEnabledEnv == null && options.llmobs) {
+      this._setBoolean(opts, 'llmobs.enabled', !!options.llmobs)
+    }
   }
 
   _isCiVisibility () {
@@ -1045,7 +1088,8 @@ class Config {
       DD_CIVISIBILITY_FLAKY_RETRY_ENABLED,
       DD_CIVISIBILITY_FLAKY_RETRY_COUNT,
       DD_TEST_SESSION_NAME,
-      DD_AGENTLESS_LOG_SUBMISSION_ENABLED
+      DD_AGENTLESS_LOG_SUBMISSION_ENABLED,
+      DD_TEST_DYNAMIC_INSTRUMENTATION_ENABLED
     } = process.env
 
     if (DD_CIVISIBILITY_AGENTLESS_URL) {
@@ -1063,6 +1107,7 @@ class Config {
       this._setBoolean(calc, 'isManualApiEnabled', !isFalse(this._isCiVisibilityManualApiEnabled()))
       this._setString(calc, 'ciVisibilityTestSessionName', DD_TEST_SESSION_NAME)
       this._setBoolean(calc, 'ciVisAgentlessLogSubmissionEnabled', isTrue(DD_AGENTLESS_LOG_SUBMISSION_ENABLED))
+      this._setBoolean(calc, 'isTestDynamicInstrumentationEnabled', isTrue(DD_TEST_DYNAMIC_INSTRUMENTATION_ENABLED))
     }
     this._setString(calc, 'dogstatsd.hostname', this._getHostname())
     this._setBoolean(calc, 'isGitUploadEnabled',
@@ -1155,7 +1200,11 @@ class Config {
     }
 
     if (typeof value === 'string') {
-      value = value.split(',')
+      value = value.split(',').map(item => {
+        // Trim each item and remove whitespace around the colon
+        const [key, val] = item.split(':').map(part => part.trim())
+        return val !== undefined ? `${key}:${val}` : key
+      })
     }
 
     if (Array.isArray(value)) {
@@ -1163,6 +1212,26 @@ class Config {
     }
   }
 
+  _setIntegerRangeSet (obj, name, value) {
+    if (value == null) {
+      return this._setValue(obj, name, null)
+    }
+    value = value.split(',')
+    const result = []
+
+    value.forEach(val => {
+      if (val.includes('-')) {
+        const [start, end] = val.split('-').map(Number)
+        for (let i = start; i <= end; i++) {
+          result.push(i)
+        }
+      } else {
+        result.push(Number(val))
+      }
+    })
+    this._setValue(obj, name, result)
+  }
+
   _setSamplingRule (obj, name, value) {
     if (value == null) {
       return this._setValue(obj, name, null)

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

@@ -44,5 +44,7 @@ module.exports = {
   SCHEMA_ID: 'schema.id',
   SCHEMA_TOPIC: 'schema.topic',
   SCHEMA_OPERATION: 'schema.operation',
-  SCHEMA_NAME: 'schema.name'
+  SCHEMA_NAME: 'schema.name',
+  GRPC_CLIENT_ERROR_STATUSES: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+  GRPC_SERVER_ERROR_STATUSES: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
 }

package/packages/dd-trace/src/datastreams/pathway.js

@@ -21,6 +21,7 @@ function shaHash (checkpointString) {
 }
 
 function computeHash (service, env, edgeTags, parentHash) {
+  edgeTags.sort()
   const hashableEdgeTags = edgeTags.filter(item => item !== 'manual_checkpoint:true')
 
   const key = `${service}${env}` + hashableEdgeTags.join('') + parentHash.toString()

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

@@ -5,7 +5,7 @@ const { breakpoints } = require('./state')
 const session = require('./session')
 const { getLocalStateForCallFrame } = require('./snapshot')
 const send = require('./send')
-const { getScriptUrlFromId } = require('./state')
+const { getStackFromCallFrames } = require('./state')
 const { ackEmitting, ackError } = require('./status')
 const { parentThreadId } = require('./config')
 const log = require('../../log')
@@ -23,12 +23,14 @@ session.on('Debugger.paused', async ({ params }) => {
   const timestamp = Date.now()
 
   let captureSnapshotForProbe = null
-  let maxReferenceDepth, maxLength
+  let maxReferenceDepth, maxCollectionSize, maxFieldCount, maxLength
   const probes = params.hitBreakpoints.map((id) => {
     const probe = breakpoints.get(id)
     if (probe.captureSnapshot) {
       captureSnapshotForProbe = probe
       maxReferenceDepth = highestOrUndefined(probe.capture.maxReferenceDepth, maxReferenceDepth)
+      maxCollectionSize = highestOrUndefined(probe.capture.maxCollectionSize, maxCollectionSize)
+      maxFieldCount = highestOrUndefined(probe.capture.maxFieldCount, maxFieldCount)
       maxLength = highestOrUndefined(probe.capture.maxLength, maxLength)
     }
     return probe
@@ -38,7 +40,10 @@ session.on('Debugger.paused', async ({ params }) => {
   if (captureSnapshotForProbe !== null) {
     try {
       // TODO: Create unique states for each affected probe based on that probes unique `capture` settings (DEBUG-2863)
-      processLocalState = await getLocalStateForCallFrame(params.callFrames[0], { maxReferenceDepth, maxLength })
+      processLocalState = await getLocalStateForCallFrame(
+        params.callFrames[0],
+        { maxReferenceDepth, maxCollectionSize, maxFieldCount, maxLength }
+      )
     } catch (err) {
       // TODO: This error is not tied to a specific probe, but to all probes with `captureSnapshot: true`.
       // However, in 99,99% of cases, there will be just a single probe, so I guess this simplification is ok?
@@ -61,16 +66,7 @@ session.on('Debugger.paused', async ({ params }) => {
     thread_name: threadName
   }
 
-  const stack = params.callFrames.map((frame) => {
-    let fileName = getScriptUrlFromId(frame.location.scriptId)
-    if (fileName.startsWith('file://')) fileName = fileName.substr(7) // TODO: This might not be required
-    return {
-      fileName,
-      function: frame.functionName,
-      lineNumber: frame.location.lineNumber + 1, // Beware! lineNumber is zero-indexed
-      columnNumber: frame.location.columnNumber + 1 // Beware! columnNumber is zero-indexed
-    }
-  })
+  const stack = getStackFromCallFrames(params.callFrames)
 
   // TODO: Send multiple probes in one HTTP request as an array (DEBUG-2848)
   for (const probe of probes) {

package/packages/dd-trace/src/debugger/devtools_client/send.js

@@ -9,6 +9,8 @@ const { GIT_COMMIT_SHA, GIT_REPOSITORY_URL } = require('../../plugins/util/tags'
 
 module.exports = send
 
+const MAX_PAYLOAD_SIZE = 1024 * 1024 // 1MB
+
 const ddsource = 'dd_debugger'
 const hostname = getHostname()
 const service = config.service
@@ -37,5 +39,17 @@ function send (message, logger, snapshot, cb) {
     'debugger.snapshot': snapshot
   }
 
-  request(JSON.stringify(payload), opts, cb)
+  let json = JSON.stringify(payload)
+
+  if (Buffer.byteLength(json) > MAX_PAYLOAD_SIZE) {
+    // TODO: This is a very crude way to handle large payloads. Proper pruning will be implemented later (DEBUG-2624)
+    const line = Object.values(payload['debugger.snapshot'].captures.lines)[0]
+    line.locals = {
+      notCapturedReason: 'Snapshot was too large',
+      size: Object.keys(line.locals).length
+    }
+    json = JSON.stringify(payload)
+  }
+
+  request(json, opts, cb)
 }