dd-trace 4.47.1 → 4.49.0

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,8 +462,12 @@ 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)
     this._setValue(defaults, 'dbmPropagationMode', 'disabled')
     this._setValue(defaults, 'dogstatsd.hostname', '127.0.0.1')
     this._setValue(defaults, 'dogstatsd.port', '8125')
@@ -476,8 +480,11 @@ 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,}')
     this._setValue(defaults, 'iast.deduplicationEnabled', true)
     this._setValue(defaults, 'iast.enabled', false)
     this._setValue(defaults, 'iast.maxConcurrentRequests', 2)
@@ -497,7 +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)
@@ -517,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)
@@ -538,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)
@@ -571,6 +585,7 @@ class Config {
       DD_APPSEC_RASP_ENABLED,
       DD_APPSEC_TRACE_RATE_LIMIT,
       DD_APPSEC_WAF_TIMEOUT,
+      DD_CODE_ORIGIN_FOR_SPANS_ENABLED,
       DD_DATA_STREAMS_ENABLED,
       DD_DBM_PROPAGATION_MODE,
       DD_DOGSTATSD_HOSTNAME,
@@ -580,7 +595,10 @@ 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,
       DD_IAST_ENABLED,
       DD_IAST_MAX_CONCURRENT_REQUESTS,
@@ -594,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,
@@ -620,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,
@@ -699,14 +724,18 @@ 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)
     this._setString(env, 'dbmPropagationMode', DD_DBM_PROPAGATION_MODE)
     this._setString(env, 'dogstatsd.hostname', DD_DOGSTATSD_HOSTNAME)
     this._setString(env, 'dogstatsd.port', DD_DOGSTATSD_PORT)
     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)
@@ -714,8 +743,11 @@ 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)
     this._setBoolean(env, 'iast.deduplicationEnabled', DD_IAST_DEDUPLICATION_ENABLED)
     this._setBoolean(env, 'iast.enabled', DD_IAST_ENABLED)
     this._setValue(env, 'iast.maxConcurrentRequests', maybeInt(DD_IAST_MAX_CONCURRENT_REQUESTS))
@@ -734,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)
@@ -867,6 +903,9 @@ 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) {
       this._setString(opts, 'dogstatsd.hostname', options.dogstatsd.hostname)
@@ -884,6 +923,7 @@ class Config {
     this._optsUnprocessed.flushMinSpans = options.flushMinSpans
     this._setArray(opts, 'headerTags', options.headerTags)
     this._setString(opts, 'hostname', options.hostname)
+    this._setString(opts, 'iast.cookieFilterPattern', options.iast?.cookieFilterPattern)
     this._setBoolean(opts, 'iast.deduplicationEnabled', options.iast && options.iast.deduplicationEnabled)
     this._setBoolean(opts, 'iast.enabled',
       options.iast && (options.iast === true || options.iast.enabled === true))
@@ -902,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)
@@ -937,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 () {
@@ -1035,7 +1087,9 @@ class Config {
       DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED,
       DD_CIVISIBILITY_FLAKY_RETRY_ENABLED,
       DD_CIVISIBILITY_FLAKY_RETRY_COUNT,
-      DD_TEST_SESSION_NAME
+      DD_TEST_SESSION_NAME,
+      DD_AGENTLESS_LOG_SUBMISSION_ENABLED,
+      DD_TEST_DYNAMIC_INSTRUMENTATION_ENABLED
     } = process.env
 
     if (DD_CIVISIBILITY_AGENTLESS_URL) {
@@ -1052,6 +1106,8 @@ class Config {
       this._setBoolean(calc, 'isIntelligentTestRunnerEnabled', isTrue(this._isCiVisibilityItrEnabled()))
       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',
@@ -1144,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)) {
@@ -1152,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/datastreams/schemas/schema_builder.js

@@ -4,13 +4,36 @@ const { Schema } = require('./schema')
 
 const maxDepth = 10
 const maxProperties = 1000
-const CACHE = new LRUCache({ max: 32 })
+const CACHE = new LRUCache({ max: 256 })
 
 class SchemaBuilder {
   constructor (iterator) {
     this.schema = new OpenApiSchema()
     this.iterator = iterator
-    this.proerties = 0
+    this.properties = 0
+  }
+
+  static getCache () {
+    return CACHE
+  }
+
+  static getSchemaDefinition (schema) {
+    const noNones = convertToJsonCompatible(schema)
+    const definition = jsonStringify(noNones)
+    const id = fnv64(Buffer.from(definition, 'utf-8')).toString()
+    return new Schema(definition, id)
+  }
+
+  static getSchema (schemaName, iterator, builder) {
+    if (!CACHE.has(schemaName)) {
+      CACHE.set(schemaName, (builder ?? new SchemaBuilder(iterator)).build())
+    }
+    return CACHE.get(schemaName)
+  }
+
+  build () {
+    this.iterator.iterateOverSchema(this)
+    return this.schema
   }
 
   addProperty (schemaName, fieldName, isArray, type, description, ref, format, enumValues) {
@@ -26,14 +49,6 @@ class SchemaBuilder {
     return true
   }
 
-  build () {
-    this.iterator.iterateOverSchema(this)
-    const noNones = convertToJsonCompatible(this.schema)
-    const definition = jsonStringify(noNones)
-    const id = fnv64(Buffer.from(definition, 'utf-8')).toString()
-    return new Schema(definition, id)
-  }
-
   shouldExtractSchema (schemaName, depth) {
     if (depth > maxDepth) {
       return false
@@ -44,13 +59,6 @@ class SchemaBuilder {
     this.schema.components.schemas[schemaName] = new OpenApiSchema.SCHEMA()
     return true
   }
-
-  static getSchema (schemaName, iterator) {
-    if (!CACHE.has(schemaName)) {
-      CACHE.set(schemaName, new SchemaBuilder(iterator).build())
-    }
-    return CACHE.get(schemaName)
-  }
 }
 
 class OpenApiSchema {

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

@@ -7,6 +7,8 @@ const log = require('../../log')
 const config = module.exports = {
   runtimeId: parentConfig.tags['runtime-id'],
   service: parentConfig.service,
+  commitSHA: parentConfig.commitSHA,
+  repositoryUrl: parentConfig.repositoryUrl,
   parentThreadId
 }
 

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

@@ -3,8 +3,10 @@
 const { randomUUID } = require('crypto')
 const { breakpoints } = require('./state')
 const session = require('./session')
+const { getLocalStateForCallFrame } = require('./snapshot')
 const send = require('./send')
-const { ackEmitting } = require('./status')
+const { getStackFromCallFrames } = require('./state')
+const { ackEmitting, ackError } = require('./status')
 const { parentThreadId } = require('./config')
 const log = require('../../log')
 const { version } = require('../../../../../package.json')
@@ -19,9 +21,38 @@ const threadName = parentThreadId === 0 ? 'MainThread' : `WorkerThread:${parentT
 session.on('Debugger.paused', async ({ params }) => {
   const start = process.hrtime.bigint()
   const timestamp = Date.now()
-  const probes = params.hitBreakpoints.map((id) => breakpoints.get(id))
+
+  let captureSnapshotForProbe = null
+  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
+  })
+
+  let processLocalState
+  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, 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?
+      ackError(err, captureSnapshotForProbe) // TODO: Ok to continue after sending ackError?
+    }
+  }
+
   await session.post('Debugger.resume')
-  const diff = process.hrtime.bigint() - start // TODO: Should this be recored as telemetry?
+  const diff = process.hrtime.bigint() - start // TODO: Recored as telemetry (DEBUG-2858)
 
   log.debug(`Finished processing breakpoints - main thread paused for: ${Number(diff) / 1000000} ms`)
 
@@ -35,7 +66,9 @@ session.on('Debugger.paused', async ({ params }) => {
     thread_name: threadName
   }
 
-  // TODO: Send multiple probes in one HTTP request as an array
+  const stack = getStackFromCallFrames(params.callFrames)
+
+  // TODO: Send multiple probes in one HTTP request as an array (DEBUG-2848)
   for (const probe of probes) {
     const snapshot = {
       id: randomUUID(),
@@ -45,13 +78,27 @@ session.on('Debugger.paused', async ({ params }) => {
         version: probe.version,
         location: probe.location
       },
+      stack,
       language: 'javascript'
     }
 
-    // TODO: Process template
+    if (probe.captureSnapshot) {
+      const state = processLocalState()
+      if (state) {
+        snapshot.captures = {
+          lines: { [probe.location.lines[0]]: { locals: state } }
+        }
+      }
+    }
+
+    // TODO: Process template (DEBUG-2628)
     send(probe.template, logger, snapshot, (err) => {
       if (err) log.error(err)
       else ackEmitting(probe)
     })
   }
 })
+
+function highestOrUndefined (num, max) {
+  return num === undefined ? max : Math.max(num, max ?? 0)
+}

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const { workerData: { rcPort } } = require('node:worker_threads')
-const { getScript, probes, breakpoints } = require('./state')
+const { findScriptFromPartialPath, probes, breakpoints } = require('./state')
 const session = require('./session')
 const { ackReceived, ackInstalled, ackError } = require('./status')
 const log = require('../../log')
@@ -92,7 +92,7 @@ async function processMsg (action, probe) {
         await addBreakpoint(probe)
         break
       case 'modify':
-        // TODO: Can we modify in place?
+        // TODO: Modify existing probe instead of removing it (DEBUG-2817)
         await removeBreakpoint(probe)
         await addBreakpoint(probe)
         break
@@ -114,13 +114,13 @@ async function addBreakpoint (probe) {
   const line = Number(probe.where.lines[0]) // Tracer doesn't support multiple-line breakpoints
 
   // Optimize for sending data to /debugger/v1/input endpoint
-  probe.location = { file, lines: [line] }
+  probe.location = { file, lines: [String(line)] }
   delete probe.where
 
   // TODO: Inbetween `await session.post('Debugger.enable')` and here, the scripts are parsed and cached.
   // Maybe there's a race condition here or maybe we're guraenteed that `await session.post('Debugger.enable')` will
   // not continue untill all scripts have been parsed?
-  const script = getScript(file)
+  const script = findScriptFromPartialPath(file)
   if (!script) throw new Error(`No loaded script found for ${file} (probe: ${probe.id}, version: ${probe.version})`)
   const [path, scriptId] = script
 

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

@@ -1,28 +1,55 @@
 'use strict'
 
+const { hostname: getHostname } = require('os')
+const { stringify } = require('querystring')
+
 const config = require('./config')
 const request = require('../../exporters/common/request')
+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
 
+const ddtags = [
+  [GIT_COMMIT_SHA, config.commitSHA],
+  [GIT_REPOSITORY_URL, config.repositoryUrl]
+].map((pair) => pair.join(':')).join(',')
+
+const path = `/debugger/v1/input?${stringify({ ddtags })}`
+
 function send (message, logger, snapshot, cb) {
   const opts = {
     method: 'POST',
     url: config.url,
-    path: '/debugger/v1/input',
+    path,
     headers: { 'Content-Type': 'application/json; charset=utf-8' }
   }
 
   const payload = {
     ddsource,
+    hostname,
     service,
     message,
     logger,
     '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)
 }