datadog 2.46.0 → 2.48.0

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

@@ -27,8 +27,18 @@ module Datadog
           cls = Class.new(Evaluator)
           cls.class_exec do
             eval(<<-RUBY, Object.new.send(:binding), __FILE__, __LINE__ + 1) # standard:disable Security/Eval
-              def evaluate(context)
-                @context = context
+              # Evaluates the compiled expression against +context+ within
+              # the cooperative evaluation +evaluation_deadline+.
+              #
+              # @param context [Context] evaluation context (locals, instance
+              #   variables, and per-invocation special variables).
+              # @param evaluation_deadline [Float] invocation-local evaluation
+              #   deadline, as CLOCK_THREAD_CPUTIME_ID float seconds.
+              # @return [Object] the value the expression evaluates to.
+              # @raise [DI::Error::ExpressionEvaluationError] the expression
+              #   failed to evaluate, including the EvaluationTimeout
+              #   subclass raised when the deadline is exceeded.
+              def evaluate(context, evaluation_deadline)
                 #{compiled_expr}
               end
             RUBY
@@ -40,12 +50,32 @@ module Datadog
         attr_reader :evaluator
         attr_reader :redaction_identifier
 
-        def evaluate(context)
-          @evaluator.evaluate(context)
+        # Evaluates the expression against +context+.
+        #
+        # @param context [Context] evaluation context (locals, instance
+        #   variables, and per-invocation special variables).
+        # @param evaluation_deadline [Float] cooperative evaluation deadline, as
+        #   CLOCK_THREAD_CPUTIME_ID float seconds.
+        # @return [Object] the value the expression evaluates to.
+        # @raise [DI::Error::ExpressionEvaluationError] the expression failed
+        #   to evaluate; DI::Error::EvaluationTimeout, raised when the
+        #   evaluation deadline is exceeded, is a subclass.
+        def evaluate(context, evaluation_deadline:)
+          evaluator.evaluate(context, evaluation_deadline)
         end
 
-        def satisfied?(context)
-          !!evaluate(context)
+        # Returns whether the expression evaluates to a truthy value
+        # against +context+.
+        #
+        # @param context [Context] evaluation context.
+        # @param evaluation_deadline [Float] cooperative evaluation deadline, as
+        #   CLOCK_THREAD_CPUTIME_ID float seconds.
+        # @return [Boolean] whether the expression is satisfied.
+        # @raise [DI::Error::ExpressionEvaluationError] the expression failed
+        #   to evaluate; DI::Error::EvaluationTimeout, raised when the
+        #   evaluation deadline is exceeded, is a subclass.
+        def satisfied?(context, evaluation_deadline:)
+          !!evaluate(context, evaluation_deadline: evaluation_deadline)
         end
       end
     end

data/lib/datadog/di/error.rb

@@ -92,6 +92,22 @@ module Datadog
       # expressions.
       class ExpressionEvaluationError < Error
       end
+
+      # Raised when expression evaluation exceeds the configured
+      # evaluation CPU-time budget, or a `matches` operator exceeds its
+      # per-match wall-clock bound.
+      class EvaluationTimeout < ExpressionEvaluationError
+        # Default message for EvaluationTimeout exceptions.
+        DEFAULT_MESSAGE = "expression evaluation timeout"
+
+        # Builds the exception, defaulting +message+ to DEFAULT_MESSAGE.
+        #
+        # @param message [String] exception message.
+        # @return [void]
+        def initialize(message: DEFAULT_MESSAGE)
+          super(message)
+        end
+      end
     end
   end
 end

data/lib/datadog/di/guardrails_telemetry/reason.rb

@@ -16,8 +16,9 @@ module Datadog
         # process-wide rate limiter.
         RATE_LIMIT_GLOBAL = "rateLimitGlobal"
 
-        # Skip reason emitted when a capture expression evaluation exceeds
-        # the capture time budget.
+        # Skip reason emitted when an evaluation exceeds its time budget:
+        # a probe condition, a capture expression (including one skipped at
+        # the expired capture time budget), or a message template.
         EVALUATION_TIMEOUT = "evaluationTimeout"
 
         # Skip reason named in the +di: debug log when a condition-evaluation

data/lib/datadog/di/instrumenter.rb

@@ -83,7 +83,7 @@ module Datadog
       # @param settings [Datadog::Core::Configuration::Settings] tracer settings
       # @param serializer [Serializer] serializer for captured values
       # @param logger [DI::Logger] logger for instrumenter diagnostics
-      # @param guardrails_telemetry [GuardrailsTelemetry] emitter for the canonical rate-limit skip metric
+      # @param guardrails_telemetry [GuardrailsTelemetry] emitter for the canonical guardrail skip metrics
       # @param capture_expression_evaluator [CaptureExpressionEvaluator] evaluator for the probe's capture expressions
       # @param code_tracker [CodeTracker, nil] code tracker for line probe installation
       # @param telemetry [Datadog::Core::Telemetry::Component, nil] component instrumenter errors are reported through
@@ -554,7 +554,8 @@ module Datadog
                 target_self: target_self,
                 probe: probe, settings: settings, serializer: serializer,
               )
-              continue = condition.satisfied?(context)
+              continue = condition.satisfied?(context,
+                evaluation_deadline: serializer.evaluation_deadline)
             rescue Exception => exc # standard:disable Lint/RescueException
               Datadog::DI.reraise_if_fatal(exc)
               # Evaluation error exception can be raised for "expected"
@@ -563,6 +564,10 @@ module Datadog
               raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions &&
                 !exc.is_a?(DI::Error::ExpressionEvaluationError)
 
+              # An evaluation timeout is an internal budget abort, so it
+              # stays contained even under propagate_all_exceptions.
+              record_condition_evaluation_timeout(probe, exc)
+
               if context
                 # We want to report evaluation errors for conditions
                 # as probe snapshots. However, if we failed to create
@@ -605,7 +610,7 @@ module Datadog
             serialized_entry_args = if probe.capture_snapshot?
               serializer.serialize_args(args, kwargs, target_self,
                 deadline: serializer.serialization_deadline,
-                **probe.snapshot_serializer_limits(settings),)
+                **probe.snapshot_serializer_limits(settings))
             end
 
             entry_capture_expressions = nil
@@ -698,7 +703,7 @@ module Datadog
               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,)
+              return_value: rv, duration: duration, exception: exc)
 
             begin
               responder.probe_executed_callback(context)
@@ -788,12 +793,16 @@ module Datadog
         public :kwargs_from_splat
       end
 
-      # Trace point callback for a line probe.
+      # Trace point callback for a line probe hit. Evaluates the probe's
+      # condition, applies the per-probe rate limiter and the global rate
+      # limiter, then invokes the responder with the built context.
       #
-      # @param probe [Probe] the probe installed on this line
-      # @param iseq [RubyVM::InstructionSequence, nil] instruction sequence the trace point is targeted at, or nil when untargeted
-      # @param responder [#probe_executed_callback, #probe_condition_evaluation_failed_callback] callback target invoked with the built Context
-      # @param tp [TracePoint] the firing trace point
+      # @param probe [Probe] the probe the trace point was installed for.
+      # @param iseq [RubyVM::InstructionSequence, nil] instruction sequence of
+      #   the probe's target file, when the trace point is targeted.
+      # @param responder [#probe_executed_callback, #probe_condition_evaluation_failed_callback, #probe_disabled_callback]
+      #   callback target for the probe hit.
+      # @param tp [TracePoint] the trace point event that fired.
       # @return [void]
       def line_trace_point_callback(probe, iseq, responder, tp)
         di_start_time = Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID)
@@ -832,7 +841,8 @@ module Datadog
         if condition = probe.condition
           begin
             context = build_trace_point_context(probe, tp)
-            return unless condition.satisfied?(context)
+            return unless condition.satisfied?(context,
+              evaluation_deadline: serializer.evaluation_deadline)
           rescue Exception => exc # standard:disable Lint/RescueException
             Datadog::DI.reraise_if_fatal(exc)
             # Evaluation error exception can be raised for "expected"
@@ -841,6 +851,10 @@ module Datadog
             raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions &&
               !exc.is_a?(DI::Error::ExpressionEvaluationError)
 
+            # An evaluation timeout is an internal budget abort, so it
+            # stays contained even under propagate_all_exceptions.
+            record_condition_evaluation_timeout(probe, exc)
+
             if context
               # We want to report evaluation errors for conditions
               # as probe snapshots. However, if we failed to create
@@ -900,6 +914,21 @@ module Datadog
         nil
       end
 
+      # Records a condition evaluation timeout for +probe+ through the
+      # shared evaluation-timeout reporter. Does nothing when +exc+ is not
+      # an evaluation timeout.
+      #
+      # @param probe [Probe] the probe whose condition evaluation timed out.
+      # @param exc [Exception] the exception raised by the evaluation.
+      # @return [void]
+      def record_condition_evaluation_timeout(probe, exc)
+        DI.report_evaluation_timeout(
+          telemetry: telemetry, guardrails_telemetry: guardrails_telemetry, logger: logger,
+          probe: probe, kind: "condition", exc: exc,
+        )
+        nil
+      end
+
       def build_trace_point_context(probe, tp)
         stack = caller_locations
         # We have two helper methods being invoked from the trace point

data/lib/datadog/di/probe_notification_builder.rb

@@ -4,6 +4,7 @@
 
 require_relative "evaluation_failure"
 require_relative "fatal_exceptions"
+require_relative "guardrails_telemetry"
 
 module Datadog
   module DI
@@ -17,12 +18,17 @@ module Datadog
       # @param serializer [Serializer] serializer for captured values
       # @param logger [DI::Logger] logger for builder diagnostics
       # @param capture_expression_evaluator [CaptureExpressionEvaluator] evaluator for the probe's capture expressions
+      # @param guardrails_telemetry [GuardrailsTelemetry] emitter for the canonical evaluation-timeout skip metric
+      # @param telemetry [Datadog::Core::Telemetry::Component, nil] component evaluation timeouts are counted through
       # @return [void]
-      def initialize(settings, serializer, logger, capture_expression_evaluator:)
+      def initialize(settings, serializer, logger, capture_expression_evaluator:, guardrails_telemetry:,
+        telemetry:)
         @settings = settings
         @serializer = serializer
         @logger = logger
         @capture_expression_evaluator = capture_expression_evaluator
+        @guardrails_telemetry = guardrails_telemetry
+        @telemetry = telemetry
       end
 
       attr_reader :settings
@@ -33,35 +39,43 @@ module Datadog
 
       attr_reader :capture_expression_evaluator
 
+      # The guardrails metric emitter.
+      # @return [GuardrailsTelemetry]
+      attr_reader :guardrails_telemetry
+
+      # The telemetry component evaluation timeouts are counted through.
+      # @return [Datadog::Core::Telemetry::Component, nil]
+      attr_reader :telemetry
+
       def build_received(probe)
         build_status(probe,
           message: "Probe #{probe.id} has been received correctly",
-          status: "RECEIVED",)
+          status: "RECEIVED")
       end
 
       def build_installed(probe)
         build_status(probe,
           message: "Probe #{probe.id} has been instrumented correctly",
-          status: "INSTALLED",)
+          status: "INSTALLED")
       end
 
       def build_emitting(probe)
         build_status(probe,
           message: "Probe #{probe.id} is emitting",
-          status: "EMITTING",)
+          status: "EMITTING")
       end
 
       def build_errored(probe, exc)
         build_status(probe,
           message: "Instrumentation for probe #{probe.id} failed: #{exc}",
           status: "ERROR",
-          exception: exc,)
+          exception: exc)
       end
 
       def build_disabled(probe, duration)
         build_status(probe,
           message: "Probe #{probe.id} was disabled because it consumed #{duration} seconds of CPU time in DI processing",
-          status: "ERROR",)
+          status: "ERROR")
       end
 
       # Duration is in seconds.
@@ -144,12 +158,13 @@ module Datadog
         message = nil
         evaluation_errors = []
         if segments = probe.template_segments
-          message, evaluation_errors = evaluate_template(segments, context)
+          message, evaluation_errors = evaluate_template(segments, context,
+            evaluation_deadline: serializer.evaluation_deadline)
         end
         evaluation_errors.concat(capture_expression_evaluation_errors)
         build_snapshot_base(context,
           evaluation_errors: evaluation_errors, message: message,
-          captures: captures,)
+          captures: captures)
       end
 
       def build_condition_evaluation_failed(context, expression, exception)
@@ -401,23 +416,56 @@ module Datadog
         end
       end
 
-      def evaluate_template(template_segments, context)
+      # Renders the probe's message template against +context+.
+      #
+      # @param template_segments [Array<String, EL::Expression>] compiled
+      #   template segments to render.
+      # @param context [Context] evaluation context for expression segments.
+      # @param evaluation_deadline [Float] cooperative evaluation deadline, as
+      #   CLOCK_THREAD_CPUTIME_ID float seconds.
+      # @return [Array(String, Array<EvaluationFailure>)] the rendered message
+      #   and the evaluation errors.
+      def evaluate_template(template_segments, context, evaluation_deadline:)
         evaluation_errors = []
+        timed_out = false
         message = template_segments.map do |segment|
+          if segment.is_a?(EL::Expression) && !timed_out &&
+              EL::Evaluator.evaluation_deadline_exceeded?(evaluation_deadline)
+            raise DI::Error::EvaluationTimeout
+          end
           case segment
           when String
             segment
           when EL::Expression
-            serializer.serialize_value_for_message(segment.evaluate(context), name: segment.redaction_identifier)
+            if timed_out
+              # The shared deadline already crossed and reported its
+              # timeout, so the remaining segments render as the
+              # placeholder rather than raising and re-reporting per
+              # segment.
+              "[evaluation error]"
+            else
+              serializer.serialize_value_for_message(segment.evaluate(context, evaluation_deadline: evaluation_deadline), name: segment.redaction_identifier)
+            end
           else
             raise ArgumentError, "Invalid template segment type: #{segment}"
           end
         rescue Exception => exc # standard:disable Lint/RescueException
           Datadog::DI.reraise_if_fatal(exc)
+          DI.report_evaluation_timeout(
+            telemetry: telemetry, guardrails_telemetry: guardrails_telemetry, logger: logger,
+            probe: context.probe, kind: "template", exc: exc,
+          )
           evaluation_errors << EvaluationFailure.new(
             expr: segment.dsl_expr, # steep:ignore NoMethod
             message: "#{exc.class}: #{exc.message}",
           )
+          # The matches wall-time bound also raises EvaluationTimeout
+          # without crossing the shared deadline, and it stops only one
+          # segment, so it must not suppress the remaining ones.
+          if exc.is_a?(DI::Error::EvaluationTimeout) &&
+              EL::Evaluator.evaluation_deadline_exceeded?(evaluation_deadline)
+            timed_out = true
+          end
           "[evaluation error]"
         end.join
         [message, evaluation_errors]

data/lib/datadog/di/probe_notifier_worker.rb

@@ -220,7 +220,7 @@ module Datadog
       # @return [DI::Transport::Input::Transport]
       def snapshot_transport
         @snapshot_transport ||= DI::Transport::HTTP.input(agent_settings: agent_settings, logger: logger,
-          telemetry: telemetry, guardrails_telemetry: guardrails_telemetry,)
+          telemetry: telemetry, guardrails_telemetry: guardrails_telemetry)
       end
 
       # Sends a batch of snapshot payloads to the agent.

data/lib/datadog/di/remote.rb

@@ -98,6 +98,9 @@ module Datadog
             # and DI.activate_tracking is defined.
             DI.activate_tracking
             was_started = component.started?
+            if repository && !was_started
+              remove_withdrawn_probes(repository, component)
+            end
             component.start!
             # A probe delivered in an earlier poll while the component was stopped
             # was dropped by #receivers (which ignores changes while !started?) and
@@ -145,7 +148,9 @@ module Datadog
             # DEV: Apply this refactor to AppSec as well if implemented.
 
             component = DI.component
-            if component&.started?
+            if changes.empty?
+              remove_withdrawn_probes(repository, component) if component
+            elsif component&.started?
               changes.each do |change|
                 case change.type
                 when :insert
@@ -176,7 +181,7 @@ module Datadog
 
         def receiver(products = [PRODUCT], &block)
           matcher = Core::Remote::Dispatcher::Matcher::Product.new(products)
-          [Core::Remote::Dispatcher::Receiver.new(matcher, &block)]
+          [Core::Remote::Dispatcher::Receiver.new(matcher, initial_reconcile: true, &block)]
         end
 
         private
@@ -266,6 +271,45 @@ module Datadog
           end
         end
 
+        # Removes every probe the component tracks whose id is absent from all
+        # LIVE_DEBUGGING contents in the repository. Reconciles backend deletions that
+        # produced no delete change for {.receivers}. Skips removal while a
+        # LIVE_DEBUGGING content fails to parse, because that content can hold any
+        # tracked probe.
+        def remove_withdrawn_probes(repository, component)
+          # @type var present_probe_ids: Array[String]
+          present_probe_ids = []
+          content_failed_to_parse = false
+          repository.contents.each do |content|
+            next unless content.path.product == PRODUCT
+
+            begin
+              present_probe_ids << parse_content(content)["id"]
+            rescue => exc
+              component.logger.debug do
+                "di: skipping withdrawn-probe reconcile, a LIVE_DEBUGGING content failed to parse: " \
+                "#{exc.class}: #{exc.message}"
+              end
+              content_failed_to_parse = true
+              break
+            end
+          end
+          return if content_failed_to_parse
+
+          probe_repository = component.probe_manager.probe_repository
+          tracked_probe_ids = probe_repository.installed_probes.keys | probe_repository.pending_probes.keys
+          (tracked_probe_ids - present_probe_ids).each do |probe_id|
+            component.logger.trace { "di: removing probe #{probe_id} withdrawn from remote configuration" }
+            component.probe_manager.remove_probe(probe_id)
+          rescue Exception => exc # standard:disable Lint/RescueException
+            Datadog::DI.reraise_if_fatal(exc)
+            raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
+
+            component.logger.debug { "di: error removing withdrawn probe #{probe_id}: #{exc.class}: #{exc.message}" }
+            component.telemetry&.report(exc, description: "Error removing withdrawn probe")
+          end
+        end
+
         def probe_known?(probe_id, component)
           repo = component.probe_manager.probe_repository
           !!(repo.find_installed(probe_id) ||

data/lib/datadog/di/serializer.rb

@@ -96,8 +96,25 @@ module Datadog
       # hex string, or UTF-8 with replacement characters) before returning
       # it from the custom serializer.
       @@flat_registry = []
-      def self.register(condition: nil, &block)
+      # Registers a custom serializer. The block serializes each value
+      # for which +condition+ returns a truthy value.
+      #
+      # @param condition [Proc] receives the value being serialized and
+      #   returns whether this serializer applies to it
+      # @param block [Proc] serializer for the values +condition+ accepts
+      # @raise [ArgumentError] if +condition+ is not a Proc or +block+ is absent
+      # @return [void]
+      def self.register(condition:, &block)
+        unless condition.is_a?(Proc)
+          raise ArgumentError, "Serializer.register condition must be a Proc, got #{condition.class}"
+        end
+
+        unless block
+          raise ArgumentError, "Serializer.register requires a serializer block"
+        end
+
         @@flat_registry << {condition: condition, proc: block}
+        nil
       end
 
       # Initializes the serializer.
@@ -114,6 +131,10 @@ module Datadog
         @logger = logger
         @guardrails_telemetry = guardrails_telemetry
         @telemetry = telemetry
+        # Evaluation budget for one expression evaluation, as thread CPU
+        # seconds, converted from max_time_to_evaluate_ms here so that
+        # deadline resolution per probe firing traverses no settings.
+        @evaluation_budget_seconds = settings.dynamic_instrumentation.max_time_to_evaluate_ms / 1000.0
       end
 
       attr_reader :settings
@@ -159,7 +180,7 @@ module Datadog
       # @param args [Array] positional arguments passed to the probed method
       # @param kwargs [Hash{Symbol => Object}] keyword arguments passed to the probed method
       # @param target_self [any] receiver of the probed method invocation
-      # @param deadline [Float] absolute capture deadline in monotonic clock seconds
+      # @param deadline [Float] absolute capture deadline in thread CPU clock seconds
       # @return [Hash{Symbol => Hash}] serialized arguments keyed by argument name
       def serialize_args(args, kwargs, target_self,
         deadline:,
@@ -169,7 +190,7 @@ module Datadog
         collection_size: nil)
         combined = combine_args(args, kwargs, target_self)
         serialize_vars(combined, depth: depth, attribute_count: attribute_count,
-          length: length, collection_size: collection_size, deadline: deadline,)
+          length: length, collection_size: collection_size, deadline: deadline)
       end
 
       # Serializes variables captured by a line probe.
@@ -178,7 +199,7 @@ module Datadog
       # of executed code.
       #
       # @param vars [Hash{Symbol => Object}] variables to serialize, keyed by variable name
-      # @param deadline [Float] absolute capture deadline in monotonic clock seconds
+      # @param deadline [Float] absolute capture deadline in thread CPU clock seconds
       # @return [Hash{Symbol => Hash}] serialized variables keyed by variable name
       def serialize_vars(vars,
         deadline:,
@@ -188,7 +209,7 @@ module Datadog
         collection_size: nil)
         vars.each_with_object({}) do |(k, v), agg|
           agg[k] = serialize_value(v, name: k, depth: depth, attribute_count: attribute_count,
-            length: length, collection_size: collection_size, deadline: deadline,)
+            length: length, collection_size: collection_size, deadline: deadline)
         end
       end
 
@@ -207,7 +228,7 @@ module Datadog
       #
       # @param value [any] value to serialize
       # @param name [Symbol, String, nil] name the value is bound to, used for redaction
-      # @param deadline [Float] absolute capture deadline in monotonic clock seconds
+      # @param deadline [Float] absolute capture deadline in thread CPU clock seconds
       # @return [Hash{Symbol => Object}] serialized value; the {type:, notCapturedReason: "timeout"} stub when the deadline is exceeded
       def serialize_value(value, deadline:,
         name: nil,
@@ -541,21 +562,34 @@ module Datadog
         "#<#{class_name(value.class)}: serialization error>"
       end
 
-      # Computes the absolute monotonic deadline (in seconds) for a capture
-      # point from max_time_to_serialize_ms. Resolve once per capture point and
-      # share across all values serialized on the built-in paths so the
-      # budget is not exceeded.
+      # Computes the absolute thread CPU time deadline (in seconds) for a
+      # capture point from max_time_to_serialize_ms.
       #
-      # @return [Float] absolute monotonic clock reading, in seconds, at
+      # @return [Float] absolute thread CPU clock reading, in seconds, at
       #   which the capture budget is exhausted
       def serialization_deadline
-        Core::Utils::Time.get_time + settings.dynamic_instrumentation.max_time_to_serialize_ms / 1000.0
+        Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_second) +
+          settings.dynamic_instrumentation.max_time_to_serialize_ms / 1000.0
+      end
+
+      # Computes the absolute thread CPU time deadline (in seconds) for an
+      # expression evaluation by adding the evaluation budget, converted
+      # from max_time_to_evaluate_ms once at construction, to the current
+      # thread CPU clock reading.
+      #
+      # @return [Float] absolute thread CPU clock reading, in seconds, at
+      #   which the evaluation budget is exhausted
+      def evaluation_deadline
+        Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_second) +
+          evaluation_budget_seconds
       end
 
       private
 
+      attr_reader :evaluation_budget_seconds
+
       def deadline_exceeded?(deadline)
-        Core::Utils::Time.get_time >= deadline
+        Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_second) >= deadline
       end
 
       MAX_MESSAGE_COLLECTION_SIZE = 3

data/lib/datadog/di.rb

@@ -173,6 +173,33 @@ module Datadog
         Datadog.send(:components).dynamic_instrumentation
       end
 
+      # Reports an evaluation timeout: increments the evaluation_timeouts
+      # telemetry counter, emits the canonical guardrail skip metric for the
+      # timeout, and logs at debug with the probe id, the evaluation kind and
+      # the exception. Returns whether +exc+ was an evaluation timeout, so
+      # callers can run timeout-specific follow-up.
+      #
+      # @param telemetry [Datadog::Core::Telemetry::Component, nil] component
+      #   the counter increments through.
+      # @param guardrails_telemetry [GuardrailsTelemetry] emitter for the
+      #   canonical evaluation-timeout skip metric.
+      # @param logger [DI::Logger] logger the timeout log writes through.
+      # @param probe [Probe] the probe whose evaluation timed out.
+      # @param kind [String] the evaluation kind, e.g. "condition",
+      #   "capture expression" or "template".
+      # @param exc [Exception] the exception raised by the evaluation.
+      # @return [Boolean] whether the exception was an evaluation timeout.
+      def report_evaluation_timeout(telemetry:, guardrails_telemetry:, logger:, probe:, kind:, exc:)
+        return false unless exc.is_a?(DI::Error::EvaluationTimeout)
+        telemetry&.inc(TELEMETRY_NAMESPACE, "evaluation_timeouts", 1)
+        guardrails_telemetry.skipped(
+          reason: GuardrailsTelemetry::Reason::EVALUATION_TIMEOUT,
+          probe: probe,
+        )
+        logger.debug { "di: probe #{probe.id}: #{kind} evaluation timed out: #{exc.class}: #{exc.message}" }
+        true
+      end
+
       # Track how many outstanding instrumentations are in DI.
       #
       # It is hard to find the actual instrumentations - there is no

data/lib/datadog/error_tracking/component.rb

@@ -36,7 +36,7 @@ module Datadog
           elsif RubyVersion.is?("< 2.7")
             logger.warn(
               "error tracking: cannot enable error tracking: Ruby 2.7+ is required, but running
-              on #{RUBY_VERSION}"
+              on #{RUBY_VERSION}",
             )
             false
           else

data/lib/datadog/error_tracking/configuration.rb

@@ -35,7 +35,7 @@ module Datadog
                     Datadog.logger.warn(
                       "Invalid handled errors scope: #{value}. " \
                       "Supported values are: #{Ext::VALID_HANDLED_ERRORS.join(" | ")}. " \
-                      "Deactivating the feature."
+                      "Deactivating the feature.",
                     )
                   end