datadog 2.45.0 → 2.46.0

data/lib/datadog/di/probe_notification_builder.rb

@@ -2,8 +2,8 @@
 
 # rubocop:disable Lint/AssignmentInCondition
 
+require_relative "evaluation_failure"
 require_relative "fatal_exceptions"
-require_relative "capture_expression_evaluator"
 
 module Datadog
   module DI
@@ -11,14 +11,18 @@ module Datadog
     #
     # @api private
     class ProbeNotificationBuilder
-      def initialize(settings, serializer, logger, telemetry: nil)
+      # Initializes the builder.
+      #
+      # @param settings [Datadog::Core::Configuration::Settings] tracer settings
+      # @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
+      # @return [void]
+      def initialize(settings, serializer, logger, capture_expression_evaluator:)
         @settings = settings
         @serializer = serializer
         @logger = logger
-        @telemetry = telemetry
-        @capture_expression_evaluator = CaptureExpressionEvaluator.new(
-          settings: settings, serializer: serializer, logger: logger, telemetry: telemetry,
-        )
+        @capture_expression_evaluator = capture_expression_evaluator
       end
 
       attr_reader :settings
@@ -27,8 +31,6 @@ module Datadog
 
       attr_reader :logger
 
-      attr_reader :telemetry
-
       attr_reader :capture_expression_evaluator
 
       def build_received(probe)
@@ -53,7 +55,7 @@ module Datadog
         build_status(probe,
           message: "Instrumentation for probe #{probe.id} failed: #{exc}",
           status: "ERROR",
-          exception: exc)
+          exception: exc,)
       end
 
       def build_disabled(probe, duration)
@@ -83,10 +85,11 @@ module Datadog
         capture_expression_evaluation_errors = []
         captures = if probe.capture_snapshot?
           snapshot_limits = probe.snapshot_serializer_limits(settings)
+          serialization_deadline = serializer.serialization_deadline
           if probe.method?
             return_arguments = {
-              "@return": serializer.serialize_value(context.return_value, **snapshot_limits),
-              self: serializer.serialize_value(context.target_self, **snapshot_limits),
+              "@return": serializer.serialize_value(context.return_value, deadline: serialization_deadline, **snapshot_limits),
+              self: serializer.serialize_value(context.target_self, deadline: serialization_deadline, **snapshot_limits),
             }
             {
               entry: {
@@ -99,10 +102,10 @@ module Datadog
             }
           elsif probe.line?
             {
-              lines: (locals = context.serialized_locals) && {
+              lines: (locals = context.serialized_locals(serialization_deadline: serialization_deadline)) && {
                 probe.line_no => {
                   locals: locals,
-                  arguments: {self: serializer.serialize_value(context.target_self, **snapshot_limits)},
+                  arguments: {self: serializer.serialize_value(context.target_self, deadline: serialization_deadline, **snapshot_limits)},
                 },
               },
             }
@@ -116,8 +119,9 @@ module Datadog
                 entry: {captureExpressions: captured_block},
               }
             else
-              captured_block, capture_expression_evaluation_errors =
-                capture_expression_evaluator.evaluate(probe, context)
+              capture_evaluation_result = capture_expression_evaluator.evaluate(probe, context)
+              captured_block = capture_evaluation_result.serialized_values
+              capture_expression_evaluation_errors = capture_evaluation_result.errors
               {
                 return: {
                   captureExpressions: captured_block,
@@ -126,8 +130,9 @@ module Datadog
               }
             end
           elsif probe.line?
-            captured_block, capture_expression_evaluation_errors =
-              capture_expression_evaluator.evaluate(probe, context)
+            capture_evaluation_result = capture_expression_evaluator.evaluate(probe, context)
+            captured_block = capture_evaluation_result.serialized_values
+            capture_expression_evaluation_errors = capture_evaluation_result.errors
             {
               lines: {
                 probe.line_no => {captureExpressions: captured_block},
@@ -144,14 +149,11 @@ module Datadog
         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)
-        error = {
-          message: "#{exception.class}: #{exception}",
-          expr: expression.dsl_expr,
-        }
+        error = EvaluationFailure.new(expr: expression.dsl_expr, message: "#{exception.class}: #{exception}")
         build_snapshot_base(context, evaluation_errors: [error])
       end
 
@@ -350,7 +352,7 @@ module Datadog
             snapshot: {
               id: SecureRandom.uuid,
               timestamp: timestamp,
-              evaluationErrors: evaluation_errors,
+              evaluationErrors: evaluation_errors.map { |failure| {expr: failure.expr, message: failure.message} },
               probe: {
                 id: probe.id,
                 version: 0,
@@ -412,10 +414,10 @@ module Datadog
           end
         rescue Exception => exc # standard:disable Lint/RescueException
           Datadog::DI.reraise_if_fatal(exc)
-          evaluation_errors << {
-            message: "#{exc.class}: #{exc.message}",
+          evaluation_errors << EvaluationFailure.new(
             expr: segment.dsl_expr, # steep:ignore NoMethod
-          }
+            message: "#{exc.class}: #{exc.message}",
+          )
           "[evaluation error]"
         end.join
         [message, evaluation_errors]

data/lib/datadog/di/probe_notifier_worker.rb

@@ -2,6 +2,8 @@
 
 require_relative "../core/semaphore"
 require_relative "fatal_exceptions"
+require_relative "guardrails_telemetry"
+require_relative "snapshot_event"
 
 module Datadog
   module DI
@@ -24,14 +26,23 @@ module Datadog
     #
     # @api private
     class ProbeNotifierWorker
+      # Initializes the background worker.
+      #
+      # @param settings [Datadog::Core::Configuration::Settings] tracer settings
+      # @param logger [DI::Logger] logger for worker diagnostics
+      # @param agent_settings [Datadog::Core::Configuration::AgentSettings] agent connection settings for the transports
       # @param probe_repository [ProbeRepository] Repository for looking up probes.
       #   Used for handling serialization errors (disabling affected probes).
       # @param probe_notification_builder [ProbeNotificationBuilder] Builder for
       #   creating status notifications. Used for reporting ERROR status.
+      # @param telemetry [Datadog::Core::Telemetry::Component, nil] component worker errors are reported through
+      # @param guardrails_telemetry [GuardrailsTelemetry] emitter for the canonical
+      #   guardrails drop metric at the queue-full admission drop
       def initialize(settings, logger, agent_settings:,
-        probe_repository:, probe_notification_builder:, telemetry: nil)
+        probe_repository:, probe_notification_builder:, guardrails_telemetry:, telemetry: nil)
         @settings = settings
         @telemetry = telemetry
+        @guardrails_telemetry = guardrails_telemetry
         @status_queue = []
         @snapshot_queue = []
         @agent_settings = agent_settings
@@ -42,6 +53,8 @@ module Datadog
         @sleep_remaining = nil
         @wake_scheduled = false
         @thread = nil
+        @status_transport = nil
+        @snapshot_transport = nil
         @pid = nil
         @flush = 0
         @probe_repository = probe_repository
@@ -51,6 +64,9 @@ module Datadog
       attr_reader :settings
       attr_reader :logger
       attr_reader :telemetry
+      # The guardrails metric emitter.
+      # @return [GuardrailsTelemetry]
+      attr_reader :guardrails_telemetry
       attr_reader :agent_settings
       attr_reader :probe_repository
       attr_reader :probe_notification_builder
@@ -188,6 +204,9 @@ module Datadog
 
       attr_reader :last_sent
 
+      # Builds and memoizes the diagnostics transport for status events.
+      #
+      # @return [DI::Transport::Diagnostics::Transport]
       def status_transport
         @status_transport ||= DI::Transport::HTTP.diagnostics(agent_settings: agent_settings, logger: logger)
       end
@@ -196,8 +215,12 @@ module Datadog
         status_transport.send_diagnostics(batch)
       end
 
+      # Builds and memoizes the snapshot input transport.
+      #
+      # @return [DI::Transport::Input::Transport]
       def snapshot_transport
-        @snapshot_transport ||= DI::Transport::HTTP.input(agent_settings: agent_settings, logger: logger, telemetry: telemetry)
+        @snapshot_transport ||= DI::Transport::HTTP.input(agent_settings: agent_settings, logger: logger,
+          telemetry: telemetry, guardrails_telemetry: guardrails_telemetry,)
       end
 
       # Sends a batch of snapshot payloads to the agent.
@@ -206,7 +229,7 @@ module Datadog
       # serialization failures via callback. This allows healthy probes
       # to continue working even when one probe produces un-serializable data.
       #
-      # @param batch [Array<Hash>] Array of snapshot payload hashes
+      # @param batch [Array<SnapshotEvent>] the snapshot events queued for sending
       def do_send_snapshot(batch)
         snapshot_transport.send_input(batch, tags, on_serialization_error: method(:handle_serialization_error))
       end
@@ -259,6 +282,12 @@ module Datadog
         # Signals the background thread to wake up (and do the sending)
         # if it has been more than 1 second since the last send of the same
         # event type.
+        #
+        # @param event [Hash] the status or snapshot payload to enqueue
+        # @param probe [Probe, nil] the probe the payload belongs to, for status log
+        #   attribution, the queue-full drop event type, and the queued
+        #   snapshot event's guardrails event type
+        # @return [void]
         define_method("add_#{event_type}") do |event, probe: nil|
           # Enqueueing reads DI configuration and writes debug/trace logs, both
           # of which can call stdlib methods (e.g. Set#include? via the
@@ -275,12 +304,28 @@ module Datadog
           begin
             @lock.synchronize do
               queue = send("#{event_type}_queue")
+              guardrails_event_type = if event_type == :snapshot
+                probe ? GuardrailsTelemetry.probe_event_type_tag(probe) : GuardrailsTelemetry::EVENT_TYPE_SNAPSHOT
+              end
               if queue.length > settings.dynamic_instrumentation.internal.snapshot_queue_capacity
                 if event_type == :status && probe
                   status = event.dig(:debugger, :diagnostics, :status)
-                  logger.debug { "di: dropping status for #{probe.type} probe at #{probe.location} (#{probe.id}): #{status} because queue is full" }
+                  logger.debug do
+                    "di: dropping status for #{probe.type} probe at #{probe.location}" \
+                      " (#{probe.id}): #{status} because queue is full" \
+                      " (#{GuardrailsTelemetry::Reason::QUEUE_FULL})"
+                  end
                 else
-                  logger.debug { "di: #{self.class.name}: dropping #{event_type} event because queue is full" }
+                  logger.debug do
+                    "di: #{self.class.name}: dropping #{event_type} event because queue is full" \
+                      " (#{GuardrailsTelemetry::Reason::QUEUE_FULL})"
+                  end
+                end
+                if event_type == :snapshot
+                  guardrails_telemetry.dropped(
+                    reason: GuardrailsTelemetry::Reason::QUEUE_FULL,
+                    event_type: guardrails_event_type,
+                  )
                 end
               else
                 if event_type == :status && probe
@@ -289,7 +334,11 @@ module Datadog
                 else
                   logger.trace { "di: #{self.class.name}: queueing #{event_type} event" }
                 end
-                queue << event
+                queue << if event_type == :snapshot
+                  SnapshotEvent.new(payload: event, event_type: guardrails_event_type)
+                else
+                  event
+                end
               end
             end
 
@@ -307,6 +356,7 @@ module Datadog
             # Worker could be not running if the process forked - check and
             # start it again in this case.
             start
+            nil
           ensure
             Datadog::DI.leave_probe unless was_in_probe
           end