datadog 2.37.0 → 2.38.0

data/lib/datadog/core/knuth_sampler.rb

@@ -32,7 +32,9 @@ module Datadog
         @knuth_factor = knuth_factor
 
         rate = rate.to_f
-        unless rate >= 0.0 && rate <= 1.0
+        # Not using `between?` here: it raises on NaN instead of falling back to 1.0 below.
+        # No current caller passes NaN, but this guards against it defensively for future ones.
+        unless rate >= 0.0 && rate <= 1.0 # rubocop:disable Style/ComparableBetween
           Datadog.logger.warn("Sample rate #{rate} is not between 0.0 and 1.0, falling back to 1.0")
           rate = 1.0
         end

data/lib/datadog/core/metrics/client.rb

@@ -157,7 +157,7 @@ module Datadog
           begin
             if send_stats? && !start.nil?
               finished = Utils::Time.get_time
-              distribution(stat, ((finished - start) * 1000), options)
+              distribution(stat, (finished - start) * 1000, options)
             end
           rescue => e
             # TODO: Likely to be redundant, since `distribution` handles its own errors.

data/lib/datadog/core/transport/http/builder.rb

@@ -108,7 +108,7 @@ module Datadog
 
                 # Resolve fallback and merge headers
                 fallback = api_options.delete(:fallback)
-                api_options[:headers] = @default_headers.merge((api_options[:headers] || {}))
+                api_options[:headers] = @default_headers.merge(api_options[:headers] || {})
 
                 # Add API::Instance with all settings
                 instances[key] = API::Instance.new(

data/lib/datadog/core/utils/at_fork_monkey_patch.rb

@@ -6,7 +6,7 @@ module Datadog
       # Monkey patches `Kernel#fork` and similar functions, adding an `at_fork` callback mechanism which
       # is used to restart observability after the VM forks (e.g. in multiprocess Ruby apps).
       module AtForkMonkeyPatch
-        AT_FORK_CHILD_BLOCKS = [] # rubocop:disable Style/MutableConstant Used to store blocks to run, mutable by design.
+        AT_FORK_CHILD_BLOCKS = [] # rubocop:disable Style/MutableConstant -- Used to store blocks to run, mutable by design.
         private_constant :AT_FORK_CHILD_BLOCKS
 
         def self.supported?

data/lib/datadog/core/utils/time.rb

@@ -8,11 +8,15 @@ module Datadog
         module_function
 
         # Current monotonic time
+        # On macOS, CLOCK_MONOTONIC only has microsecond precision,
+        # so we use CLOCK_MONOTONIC_RAW which has nanosecond precision instead.
         #
         # @param unit [Symbol] unit for the resulting value, same as ::Process#clock_gettime, defaults to :float_second
         # @return [Float|Integer] timestamp in the requested unit, since some unspecified starting point
+        MONOTONIC_CLOCK_ID = RUBY_PLATFORM.include?("darwin") ? Process::CLOCK_MONOTONIC_RAW : Process::CLOCK_MONOTONIC
+
         def get_time(unit = :float_second)
-          Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
+          Process.clock_gettime(MONOTONIC_CLOCK_ID, unit)
         end
 
         # Current wall time.

data/lib/datadog/di/boot.rb

@@ -6,6 +6,9 @@ require_relative 'error'
 require_relative 'code_tracker'
 require_relative 'component'
 require_relative 'context'
+require_relative 'capture_limits'
+require_relative 'capture_expression'
+require_relative 'capture_expression_evaluator'
 require_relative 'instrumenter'
 require_relative 'probe'
 require_relative 'probe_builder'

data/lib/datadog/di/capture_expression.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "capture_limits"
+
+module Datadog
+  module DI
+    class CaptureExpression
+      def initialize(name:, expr:, limits: nil)
+        @name = name
+        @expr = expr
+        @limits = limits
+      end
+
+      attr_reader :name
+
+      attr_reader :expr
+
+      attr_reader :limits
+    end
+  end
+end

data/lib/datadog/di/capture_expression_evaluator.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "capture_expression"
+require_relative "capture_limits"
+require_relative "fatal_exceptions"
+
+module Datadog
+  module DI
+    class CaptureExpressionEvaluator
+      TELEMETRY_NAMESPACE = "dynamic_instrumentation"
+
+      def initialize(settings:, serializer:, logger:, telemetry: nil)
+        @settings = settings
+        @serializer = serializer
+        @logger = logger
+        @telemetry = telemetry
+      end
+
+      attr_reader :settings
+
+      attr_reader :serializer
+
+      attr_reader :logger
+
+      attr_reader :telemetry
+
+      def evaluate(probe, context)
+        budget_ns = settings.dynamic_instrumentation.max_time_to_serialize_ms * 1_000_000
+        deadline_ns = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :nanosecond) + budget_ns
+
+        output = {}
+        evaluation_errors = []
+
+        probe.capture_expressions.each do |capture_expression|
+          name = capture_expression.name
+
+          if ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :nanosecond) >= deadline_ns
+            output[name] = {notCapturedReason: "timeout"}
+            telemetry&.inc(TELEMETRY_NAMESPACE, "capture_expressions_skipped_by_timeout", 1)
+            next
+          end
+
+          begin
+            value = capture_expression.expr.evaluate(context)
+            limits = CaptureLimits.resolve(
+              expr_limits: capture_expression.limits,
+              probe: probe,
+              settings: settings,
+            )
+            output[name] = serializer.serialize_value(
+              value, name: name,
+              depth: limits[:depth],
+              attribute_count: limits[:attribute_count],
+              length: limits[:length],
+              collection_size: limits[:collection_size],
+            )
+          rescue Exception => exc # standard:disable Lint/RescueException
+            Datadog::DI.reraise_if_fatal(exc)
+            evaluation_errors << {expr: name, message: "#{exc.class}: #{exc.message}"}
+            logger.debug do
+              "di: probe #{probe.id}: capture expression #{name}: evaluation failed: #{exc.class}: #{exc.message}"
+            end
+            telemetry&.report(exc, description: "DI capture-expression evaluation failed")
+          end
+        end
+
+        [output, evaluation_errors]
+      end
+    end
+  end
+end

data/lib/datadog/di/capture_limits.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Datadog
+  module DI
+    class CaptureLimits
+      def initialize(max_reference_depth: nil, max_collection_size: nil,
+        max_length: nil, max_field_count: nil)
+        @max_reference_depth = max_reference_depth
+        @max_collection_size = max_collection_size
+        @max_length = max_length
+        @max_field_count = max_field_count
+      end
+
+      attr_reader :max_reference_depth
+
+      attr_reader :max_collection_size
+
+      attr_reader :max_length
+
+      attr_reader :max_field_count
+
+      def self.resolve(expr_limits:, probe:, settings:)
+        di = settings.dynamic_instrumentation
+        {
+          depth: expr_limits&.max_reference_depth ||
+            probe.max_capture_depth ||
+            di.max_capture_depth,
+          collection_size: expr_limits&.max_collection_size ||
+            probe.max_capture_collection_size ||
+            di.max_capture_collection_size,
+          length: expr_limits&.max_length ||
+            probe.max_capture_string_length ||
+            di.max_capture_string_length,
+          attribute_count: expr_limits&.max_field_count ||
+            probe.max_capture_attribute_count ||
+            di.max_capture_attribute_count,
+        }
+      end
+    end
+  end
+end

data/lib/datadog/di/component.rb

@@ -76,7 +76,7 @@ module Datadog
         @serializer = Serializer.new(settings, redactor, telemetry: telemetry)
         @instrumenter = Instrumenter.new(settings, serializer, logger, code_tracker: code_tracker, telemetry: telemetry)
         @probe_repository = ProbeRepository.new
-        @probe_notification_builder = ProbeNotificationBuilder.new(settings, serializer)
+        @probe_notification_builder = ProbeNotificationBuilder.new(settings, serializer, logger, telemetry: telemetry)
         @probe_notifier_worker = ProbeNotifierWorker.new(
           settings, logger,
           agent_settings: agent_settings,
@@ -185,7 +185,7 @@ module Datadog
       end
 
       def parse_probe_spec_and_notify(probe_spec)
-        probe = ProbeBuilder.build_from_remote_config(probe_spec)
+        probe = ProbeBuilder.build_from_remote_config(probe_spec, logger: logger)
       rescue Exception => exc # standard:disable Lint/RescueException
         Datadog::DI.reraise_if_fatal(exc)
         begin

data/lib/datadog/di/configuration.rb

@@ -134,6 +134,12 @@ module Datadog
                 o.default 20
               end
 
+              option :max_time_to_serialize_ms do |o|
+                o.type :int
+                o.default 200
+                o.env 'DD_DYNAMIC_INSTRUMENTATION_MAX_TIME_TO_SERIALIZE'
+              end
+
               # Settings in the 'internal' group are for internal Datadog
               # use only, and are needed to test dynamic instrumentation or
               # experiment with features not released to customers.

data/lib/datadog/di/context.rb

@@ -14,6 +14,8 @@ module Datadog
         target_self: nil,
         path: nil, caller_locations: nil,
         serialized_entry_args: nil,
+        entry_capture_expressions: nil,
+        entry_capture_evaluation_errors: nil,
         return_value: nil, duration: nil, exception: nil)
         @probe = probe
         @settings = settings
@@ -23,6 +25,8 @@ module Datadog
         @path = path
         @caller_locations = caller_locations
         @serialized_entry_args = serialized_entry_args
+        @entry_capture_expressions = entry_capture_expressions
+        @entry_capture_evaluation_errors = entry_capture_evaluation_errors
         @return_value = return_value
         @duration = duration
         @exception = exception
@@ -44,6 +48,10 @@ module Datadog
 
       attr_reader :serialized_entry_args
 
+      attr_reader :entry_capture_expressions
+
+      attr_reader :entry_capture_evaluation_errors
+
       # Return value for the method, for a method probe
       attr_reader :return_value
 
@@ -55,9 +63,7 @@ module Datadog
 
       def serialized_locals
         # TODO cache?
-        locals && serializer.serialize_vars(locals,
-          depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
-          attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count,)
+        locals && serializer.serialize_vars(locals, **probe.snapshot_serializer_limits(settings))
       end
 
       def fetch(var_name)

data/lib/datadog/di/el/compiler.rb

@@ -78,7 +78,7 @@ module Datadog
                 # We could format to a string here but what if customer
                 # has @duration as part of an expression and wants
                 # to retain it as a number?
-                "(context.duration * 1000)"
+                "(context.duration && context.duration * 1000)"
               when '@exception'
                 "context.exception"
               else

data/lib/datadog/di/instrumenter.rb

@@ -3,6 +3,7 @@
 require_relative '../core/utils/time'
 require_relative '../ruby_version'
 require_relative 'fatal_exceptions'
+require_relative 'capture_expression_evaluator'
 
 # rubocop:disable Lint/AssignmentInCondition
 # rubocop:disable Style/AndOr
@@ -84,6 +85,12 @@ module Datadog
       attr_reader :telemetry
       attr_reader :code_tracker
 
+      def capture_expression_evaluator
+        @capture_expression_evaluator ||= CaptureExpressionEvaluator.new(
+          settings: settings, serializer: serializer, logger: logger, telemetry: telemetry,
+        )
+      end
+
       # This is a substitute for Thread::Backtrace::Location
       # which does not have a public constructor.
       # Used for the fabricated stack frame for the method itself
@@ -520,8 +527,27 @@ module Datadog
             # they need to be serialized prior to method invocation.
             serialized_entry_args = if probe.capture_snapshot?
               serializer.serialize_args(args, kwargs, target_self,
-                depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
-                attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count)
+                **probe.snapshot_serializer_limits(settings))
+            end
+
+            entry_capture_expressions = nil
+            entry_capture_evaluation_errors = nil
+            if probe.capture_entry_expressions?
+              begin
+                entry_context = Context.new(
+                  probe: probe, settings: settings, serializer: serializer,
+                  target_self: target_self,
+                  locals: serializer.combine_args(args, kwargs, target_self),
+                )
+                entry_capture_expressions, entry_capture_evaluation_errors =
+                  capture_expression_evaluator.evaluate(probe, entry_context)
+              rescue Exception => exc # standard:disable Lint/RescueException
+                Datadog::DI.reraise_if_fatal(exc)
+                raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions
+
+                logger.debug { "di: error evaluating entry-time capture expressions: #{exc.class}: #{exc.message}" }
+                telemetry&.report(exc, description: "Error evaluating entry-time capture expressions")
+              end
             end
             # We intentionally do not use Core::Utils::Time.get_time
             # here because the time provider may be overridden by the
@@ -584,9 +610,14 @@ module Datadog
             caller_locs = method_frame + (caller_locations(2) || [])
             # TODO capture arguments at exit
 
-            context = Context.new(locals: nil, target_self: target_self,
+            capture_expression_locals = if probe.capture_expressions_only?
+              serializer.combine_args(args, kwargs, target_self)
+            end
+            context = Context.new(locals: capture_expression_locals, target_self: target_self,
               probe: probe, settings: settings, serializer: serializer,
               serialized_entry_args: serialized_entry_args,
+              entry_capture_expressions: entry_capture_expressions,
+              entry_capture_evaluation_errors: entry_capture_evaluation_errors,
               caller_locations: caller_locs,
               return_value: rv, duration: duration, exception: exc,)
 

data/lib/datadog/di/probe.rb

@@ -34,11 +34,17 @@ module Datadog
     class Probe
       KNOWN_TYPES = %i[log].freeze
 
+      EVALUATE_AT_VALUES = %i[entry exit].freeze
+
       def initialize(id:, type:,
         file: nil, line_no: nil, type_name: nil, method_name: nil,
         template: nil, template_segments: nil,
         capture_snapshot: false, max_capture_depth: nil,
-        max_capture_attribute_count: nil, condition: nil,
+        max_capture_attribute_count: nil,
+        max_capture_collection_size: nil, max_capture_string_length: nil,
+        capture_expressions: [],
+        evaluate_at: nil,
+        condition: nil,
         rate_limit: nil)
         # Perform some sanity checks here to detect unexpected attribute
         # combinations, in order to not do them in subsequent code.
@@ -81,9 +87,17 @@ module Datadog
         @capture_snapshot = !!capture_snapshot
         @max_capture_depth = max_capture_depth
         @max_capture_attribute_count = max_capture_attribute_count
+        @max_capture_collection_size = max_capture_collection_size
+        @max_capture_string_length = max_capture_string_length
+        @capture_expressions = capture_expressions || []
+        evaluate_at = :exit if evaluate_at.nil?
+        unless EVALUATE_AT_VALUES.include?(evaluate_at)
+          raise ArgumentError, "Unknown evaluate_at value: #{evaluate_at.inspect} (expected one of #{EVALUATE_AT_VALUES.inspect})"
+        end
+        @evaluate_at = evaluate_at
         @condition = condition
 
-        @rate_limit = rate_limit || (@capture_snapshot ? 1 : 5000)
+        @rate_limit = rate_limit || ((@capture_snapshot || !@capture_expressions.empty?) ? 1 : 5000)
         @rate_limiter = Datadog::Core::TokenBucket.new(@rate_limit)
 
         # At most one report per second.
@@ -120,6 +134,14 @@ module Datadog
       # the global default will be used.
       attr_reader :max_capture_attribute_count
 
+      attr_reader :max_capture_collection_size
+
+      attr_reader :max_capture_string_length
+
+      attr_reader :capture_expressions
+
+      attr_reader :evaluate_at
+
       # Rate limit in effect, in invocations per second. Always present.
       attr_reader :rate_limit
 
@@ -140,6 +162,29 @@ module Datadog
         @capture_snapshot
       end
 
+      def capture_expressions?
+        !@capture_expressions.empty?
+      end
+
+      def evaluate_at_entry?
+        evaluate_at == :entry
+      end
+
+      # Capture-expression mode: the probe captures expressions but not a full
+      # snapshot. Snapshot capture serializes its own values, so expression
+      # capture only runs when a snapshot is not being taken.
+      def capture_expressions_only?
+        capture_expressions? && !capture_snapshot?
+      end
+
+      def capture_entry_expressions?
+        capture_expressions_only? && evaluate_at_entry?
+      end
+
+      def snapshot_serializer_limits(settings)
+        CaptureLimits.resolve(expr_limits: nil, probe: self, settings: settings)
+      end
+
       # Returns whether the probe is a line probe.
       #
       # Method probes may still specify a file name (to aid in locating the

data/lib/datadog/di/probe_builder.rb

@@ -3,6 +3,8 @@
 # rubocop:disable Lint/AssignmentInCondition
 
 require_relative "probe"
+require_relative "capture_expression"
+require_relative "capture_limits"
 require_relative 'el'
 
 module Datadog
@@ -27,7 +29,15 @@ module Datadog
 
       module_function
 
-      def build_from_remote_config(config)
+      CAPTURE_EXPRESSION_NAME_PATTERN = /\A[a-zA-Z0-9_?]+\z/
+
+      EVALUATE_AT_STRINGS = {
+        "ENTRY" => :entry,
+        "EXIT" => :exit,
+        "DEFAULT" => :exit,
+      }.freeze
+
+      def build_from_remote_config(config, logger:)
         # The validations here are not yet comprehensive.
         type = config.fetch('type')
         type_symbol = PROBE_TYPES[type] or raise ArgumentError, "Unrecognized probe type: #{type}"
@@ -38,6 +48,13 @@ module Datadog
           compiled = EL::Compiler.new.compile(cond_spec['json'])
           EL::Expression.new(cond_spec['dsl'], compiled)
         end
+        capture_expressions = build_capture_expressions(config['captureExpressions'])
+        capture_expressions = dedup_capture_expressions(capture_expressions, config["id"], logger)
+        if !!config["captureSnapshot"] && !capture_expressions.empty?
+          logger.debug do
+            "di: probe #{config["id"]}: captureSnapshot=true wins over captureExpressions (n=#{capture_expressions.size})"
+          end
+        end
         Probe.new(
           id: config.fetch("id"),
           type: type_symbol,
@@ -54,6 +71,10 @@ module Datadog
           capture_snapshot: !!config["captureSnapshot"],
           max_capture_depth: config["capture"]&.[]("maxReferenceDepth"),
           max_capture_attribute_count: config["capture"]&.[]("maxFieldCount"),
+          max_capture_collection_size: config["capture"]&.[]("maxCollectionSize"),
+          max_capture_string_length: config["capture"]&.[]("maxLength"),
+          capture_expressions: capture_expressions,
+          evaluate_at: parse_evaluate_at(config["evaluateAt"], config["id"], logger),
           rate_limit: config["sampling"]&.[]("snapshotsPerSecond"),
           condition: cond,
         )
@@ -61,6 +82,67 @@ module Datadog
         raise ArgumentError, "Malformed remote configuration entry for probe: #{exc.class}: #{exc.message}: #{config}"
       end
 
+      def build_capture_expressions(raw)
+        return [] if raw.nil?
+        unless Array === raw
+          raise ArgumentError, "captureExpressions must be an array, got: #{raw.class}"
+        end
+        return [] if raw.empty?
+        raw.map do |entry|
+          unless Hash === entry
+            raise ArgumentError, "captureExpressions entry must be a hash, got: #{entry.class}"
+          end
+          name = entry['name']
+          unless String === name && CAPTURE_EXPRESSION_NAME_PATTERN.match?(name)
+            raise ArgumentError, "captureExpressions entry name missing or invalid (must match #{CAPTURE_EXPRESSION_NAME_PATTERN.inspect}): #{name.inspect}"
+          end
+          expr_spec = entry['expr']
+          unless Hash === expr_spec && expr_spec['dsl'] && expr_spec['json']
+            raise ArgumentError, "captureExpressions entry #{name}: missing or malformed expr"
+          end
+          compiled = EL::Compiler.new.compile(expr_spec['json'])
+          expr = EL::Expression.new(expr_spec['dsl'], compiled)
+          limits = build_capture_limits(entry['capture'])
+          CaptureExpression.new(name: name, expr: expr, limits: limits)
+        end
+      end
+
+      def dedup_capture_expressions(capture_expressions, probe_id, logger)
+        return capture_expressions if capture_expressions.size < 2
+        by_name = {}
+        capture_expressions.each do |capture_expression|
+          by_name[capture_expression.name] = capture_expression
+        end
+        return capture_expressions if by_name.size == capture_expressions.size
+        logger.debug do
+          "di: probe #{probe_id}: collapsed duplicate captureExpressions names, kept last per name (#{capture_expressions.size} -> #{by_name.size})"
+        end
+        by_name.values
+      end
+
+      def build_capture_limits(raw)
+        return nil if raw.nil?
+        unless Hash === raw
+          raise ArgumentError, "capture-expression entry capture must be a hash, got: #{raw.class}"
+        end
+        CaptureLimits.new(
+          max_reference_depth: raw['maxReferenceDepth'],
+          max_collection_size: raw['maxCollectionSize'],
+          max_length: raw['maxLength'],
+          max_field_count: raw['maxFieldCount'],
+        )
+      end
+
+      def parse_evaluate_at(raw, probe_id, logger)
+        return :exit if raw.nil?
+        EVALUATE_AT_STRINGS[raw] || begin
+          logger.debug do
+            "di: probe #{probe_id}: unrecognized evaluateAt value #{raw.inspect}, defaulting to :exit"
+          end
+          :exit
+        end
+      end
+
       def build_template_segments(segments)
         segments&.map do |segment|
           if Hash === segment

data/lib/datadog/di/probe_notification_builder.rb

@@ -3,6 +3,7 @@
 # rubocop:disable Lint/AssignmentInCondition
 
 require_relative 'fatal_exceptions'
+require_relative 'capture_expression_evaluator'
 
 module Datadog
   module DI
@@ -10,14 +11,26 @@ module Datadog
     #
     # @api private
     class ProbeNotificationBuilder
-      def initialize(settings, serializer)
+      def initialize(settings, serializer, logger, telemetry: nil)
         @settings = settings
         @serializer = serializer
+        @logger = logger
+        @telemetry = telemetry
+        @capture_expression_evaluator = CaptureExpressionEvaluator.new(
+          settings: settings, serializer: serializer, logger: logger, telemetry: telemetry,
+        )
       end
 
       attr_reader :settings
+
       attr_reader :serializer
 
+      attr_reader :logger
+
+      attr_reader :telemetry
+
+      attr_reader :capture_expression_evaluator
+
       def build_received(probe)
         build_status(probe,
           message: "Probe #{probe.id} has been received correctly",
@@ -67,13 +80,13 @@ module Datadog
 
         # TODO also verify that non-capturing probe does not pass
         # snapshot or vars/args into this method
+        capture_expression_evaluation_errors = []
         captures = if probe.capture_snapshot?
+          snapshot_limits = probe.snapshot_serializer_limits(settings)
           if probe.method?
             return_arguments = {
-              "@return": serializer.serialize_value(context.return_value,
-                depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
-                attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count),
-              self: serializer.serialize_value(context.target_self),
+              "@return": serializer.serialize_value(context.return_value, **snapshot_limits),
+              self: serializer.serialize_value(context.target_self, **snapshot_limits),
             }
             {
               entry: {
@@ -89,11 +102,38 @@ module Datadog
               lines: (locals = context.serialized_locals) && {
                 probe.line_no => {
                   locals: locals,
-                  arguments: {self: serializer.serialize_value(context.target_self)},
+                  arguments: {self: serializer.serialize_value(context.target_self, **snapshot_limits)},
                 },
               },
             }
           end
+        elsif probe.capture_expressions?
+          if probe.method?
+            if probe.evaluate_at_entry?
+              captured_block = context.entry_capture_expressions || {}
+              capture_expression_evaluation_errors = context.entry_capture_evaluation_errors || []
+              {
+                entry: {captureExpressions: captured_block},
+              }
+            else
+              captured_block, capture_expression_evaluation_errors =
+                capture_expression_evaluator.evaluate(probe, context)
+              {
+                return: {
+                  captureExpressions: captured_block,
+                  throwable: context.exception ? serialize_throwable(context.exception) : nil,
+                },
+              }
+            end
+          elsif probe.line?
+            captured_block, capture_expression_evaluation_errors =
+              capture_expression_evaluator.evaluate(probe, context)
+            {
+              lines: {
+                probe.line_no => {captureExpressions: captured_block},
+              },
+            }
+          end
         end
 
         message = nil
@@ -101,6 +141,7 @@ module Datadog
         if segments = probe.template_segments
           message, evaluation_errors = evaluate_template(segments, context)
         end
+        evaluation_errors.concat(capture_expression_evaluation_errors)
         build_snapshot_base(context,
           evaluation_errors: evaluation_errors, message: message,
           captures: captures)
@@ -305,7 +346,7 @@ module Datadog
             # except there is currently no consensus on said heuristics.
             # .NET always sends ld, other languages send nothing at the moment.
             # Don't send anything for the time being.
-            #product: 'di/ld',
+            # product: 'di/ld',
             snapshot: {
               id: SecureRandom.uuid,
               timestamp: timestamp,

data/lib/datadog/di/remote.rb

@@ -228,7 +228,7 @@ module Datadog
           # we need to note it as being current so that we do not
           # try to remove instrumentation that is still supposed to be
           # active.
-          #current_probe_ids[probe_spec.fetch('id')] = true
+          # current_probe_ids[probe_spec.fetch('id')] = true
         rescue Exception => exc # standard:disable Lint/RescueException
           Datadog::DI.reraise_if_fatal(exc)
           raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions