cw-datadog 2.23.0.2

data/lib/datadog/di/probe_notification_builder.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/AssignmentInCondition
+
+module Datadog
+  module DI
+    # Builds probe status notification and snapshot payloads.
+    #
+    # @api private
+    class ProbeNotificationBuilder
+      def initialize(settings, serializer)
+        @settings = settings
+        @serializer = serializer
+      end
+
+      attr_reader :settings
+      attr_reader :serializer
+
+      def build_received(probe)
+        build_status(probe,
+          message: "Probe #{probe.id} has been received correctly",
+          status: 'RECEIVED',)
+      end
+
+      def build_installed(probe)
+        build_status(probe,
+          message: "Probe #{probe.id} has been instrumented correctly",
+          status: 'INSTALLED',)
+      end
+
+      def build_emitting(probe)
+        build_status(probe,
+          message: "Probe #{probe.id} is emitting",
+          status: 'EMITTING',)
+      end
+
+      def build_errored(probe, exc)
+        build_status(probe,
+          message: "Instrumentation for probe #{probe.id} failed: #{exc}",
+          status: 'ERROR',)
+      end
+
+      # Duration is in seconds.
+      # path is the actual path of the instrumented file.
+      def build_executed(context)
+        build_snapshot(context)
+      end
+
+      NANOSECONDS = 10**9
+      MILLISECONDS = 1000
+
+      def build_snapshot(context)
+        probe = context.probe
+
+        if probe.capture_snapshot? && !context.target_self
+          raise ArgumentError, "Asked to build snapshot with snapshot capture but target_self is nil"
+        end
+
+        # TODO also verify that non-capturing probe does not pass
+        # snapshot or vars/args into this method
+        captures = if probe.capture_snapshot?
+          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),
+            }
+            {
+              entry: {
+                arguments: context.serialized_entry_args,
+              },
+              return: {
+                arguments: return_arguments,
+                throwable: nil,
+              },
+            }
+          elsif probe.line?
+            {
+              lines: (locals = context.serialized_locals) && {
+                probe.line_no => {
+                  locals: locals,
+                  arguments: {self: serializer.serialize_value(context.target_self)},
+                },
+              },
+            }
+          end
+        end
+
+        message = nil
+        evaluation_errors = []
+        if segments = probe.template_segments
+          message, evaluation_errors = evaluate_template(segments, context)
+        end
+        build_snapshot_base(context,
+          evaluation_errors: evaluation_errors, message: message,
+          captures: captures)
+      end
+
+      def build_condition_evaluation_failed(context, expression, exception)
+        error = {
+          message: "#{exception.class}: #{exception}",
+          expr: expression.dsl_expr,
+        }
+        build_snapshot_base(context, evaluation_errors: [error])
+      end
+
+      private
+
+      def build_snapshot_base(context, evaluation_errors: [], captures: nil, message: nil)
+        probe = context.probe
+
+        timestamp = timestamp_now
+        duration = context.duration
+
+        location = if probe.line?
+          {
+            file: context.path,
+            lines: [probe.line_no],
+          }
+        elsif probe.method?
+          {
+            method: probe.method_name,
+            type: probe.type_name,
+          }
+        end
+
+        stack = if caller_locations = context.caller_locations
+          format_caller_locations(caller_locations)
+        end
+
+        {
+          service: settings.service,
+          "debugger.snapshot": {
+            id: SecureRandom.uuid,
+            timestamp: timestamp,
+            evaluationErrors: evaluation_errors,
+            probe: {
+              id: probe.id,
+              version: 0,
+              location: location,
+            },
+            language: 'ruby',
+            # TODO add test coverage for callers being nil
+            stack: stack,
+            captures: captures,
+          },
+          # In python tracer duration is under debugger.snapshot,
+          # but UI appears to expect it here at top level.
+          duration: duration ? (duration * NANOSECONDS).to_i : 0,
+          host: nil,
+          logger: {
+            name: probe.file,
+            method: probe.method_name,
+            thread_name: Thread.current.name,
+            # Dynamic instrumentation currently does not need thread_id for
+            # anything. It can be sent if a customer requests it at which point
+            # we can also determine which thread identifier to send
+            # (Thread#native_thread_id or something else).
+            thread_id: nil,
+            version: 2,
+          },
+          # TODO add tests that the trace/span id is correctly propagated
+          "dd.trace_id": active_trace&.id&.to_s,
+          "dd.span_id": active_span&.id&.to_s,
+          ddsource: 'dd_debugger',
+          message: message,
+          timestamp: timestamp,
+        }
+      end
+
+      def build_status(probe, message:, status:)
+        {
+          service: settings.service,
+          timestamp: timestamp_now,
+          message: message,
+          ddsource: 'dd_debugger',
+          debugger: {
+            diagnostics: {
+              probeId: probe.id,
+              probeVersion: 0,
+              runtimeId: Core::Environment::Identity.id,
+              parentId: nil,
+              status: status,
+            },
+          },
+        }
+      end
+
+      def format_caller_locations(caller_locations)
+        caller_locations.map do |loc|
+          {fileName: loc.path, function: loc.label, lineNumber: loc.lineno}
+        end
+      end
+
+      def evaluate_template(template_segments, context)
+        evaluation_errors = []
+        message = template_segments.map do |segment|
+          case segment
+          when String
+            segment
+          when EL::Expression
+            serializer.serialize_value_for_message(segment.evaluate(context))
+          else
+            raise ArgumentError, "Invalid template segment type: #{segment}"
+          end
+        rescue => exc
+          evaluation_errors << {
+            message: "#{exc.class}: #{exc}",
+            expr: segment.dsl_expr,
+          }
+          '[evaluation error]'
+        end.join
+        [message, evaluation_errors]
+      end
+
+      def timestamp_now
+        (Core::Utils::Time.now.to_f * MILLISECONDS).to_i
+      end
+
+      def active_trace
+        if defined?(Datadog::Tracing)
+          Datadog::Tracing.active_trace
+        end
+      end
+
+      def active_span
+        if defined?(Datadog::Tracing)
+          Datadog::Tracing.active_span
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Lint/AssignmentInCondition

data/lib/datadog/di/probe_notifier_worker.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require_relative '../core/semaphore'
+
+module Datadog
+  module DI
+    # Background worker thread for sending probe statuses and snapshots
+    # to the backend (via the agent).
+    #
+    # The loop inside the worker rescues all exceptions to prevent termination
+    # due to unhandled exceptions raised by any downstream code.
+    # This includes communication and protocol errors when sending the
+    # events to the agent.
+    #
+    # The worker groups the data to send into batches. The goal is to perform
+    # no more than one network operation per event type per second.
+    # There is also a limit on the length of the sending queue to prevent
+    # it from growing without bounds if upstream code generates an enormous
+    # number of events for some reason.
+    #
+    # Wake-up events are used (via ConditionVariable) to keep the thread
+    # asleep if there is no work to be done.
+    #
+    # @api private
+    class ProbeNotifierWorker
+      def initialize(settings, logger, agent_settings:, telemetry: nil)
+        @settings = settings
+        @telemetry = telemetry
+        @status_queue = []
+        @snapshot_queue = []
+        @agent_settings = agent_settings
+        @logger = logger
+        @lock = Mutex.new
+        @wake = Core::Semaphore.new
+        @io_in_progress = false
+        @sleep_remaining = nil
+        @wake_scheduled = false
+        @thread = nil
+        @pid = nil
+        @flush = 0
+      end
+
+      attr_reader :settings
+      attr_reader :logger
+      attr_reader :telemetry
+      attr_reader :agent_settings
+
+      def start
+        return if @thread && @pid == Process.pid
+        logger.trace { "di: starting probe notifier: pid #{$$}" }
+        @thread = Thread.new do
+          loop do
+            # TODO If stop is requested, we stop immediately without
+            # flushing the submissions. Should we send pending submissions
+            # and then quit?
+            break if @stop_requested
+
+            # If a flush was requested, send immediately and do not
+            # wait for the cooldown period.
+            if @lock.synchronize { @flush } == 0
+              sleep_remaining = @lock.synchronize do
+                if sleep_remaining && sleep_remaining > 0
+                  # Recalculate how much sleep time is remaining, then sleep that long.
+                  set_sleep_remaining
+                else
+                  0
+                end
+              end
+
+              if sleep_remaining > 0
+                # Do not need to update @wake_scheduled here because
+                # wake-up is already scheduled for the earliest possible time.
+                wake.wait(sleep_remaining)
+                next
+              end
+            end
+
+            begin
+              more = maybe_send
+            rescue => exc
+              raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions
+
+              logger.debug { "di: error in probe notifier worker: #{exc.class}: #{exc} (at #{exc.backtrace.first})" }
+              telemetry&.report(exc, description: "Error in probe notifier worker")
+            end
+            @lock.synchronize do
+              @wake_scheduled = more
+            end
+            wake.wait(more ? min_send_interval : nil)
+          end
+        end
+        @pid = Process.pid
+      end
+
+      # Stops the background thread.
+      #
+      # Attempts a graceful stop with the specified timeout, then falls back
+      # to killing the thread using Thread#kill.
+      def stop(timeout = 1)
+        @stop_requested = true
+        logger.trace { "di: stopping probe notifier: pid #{$$}" }
+        wake.signal
+        if thread
+          unless thread.join(timeout)
+            thread.kill
+          end
+          @thread = nil
+        end
+      end
+
+      # Waits for background thread to send pending notifications.
+      #
+      # This method waits for the notification queue to become empty
+      # rather than for a particular set of notifications to be sent out,
+      # therefore, it should only be called when there is no parallel
+      # activity (in another thread) that causes more notifications
+      # to be generated.
+      #
+      # This method is used by the test suite to wait until notifications have
+      # been sent out, and could be used for graceful stopping of the
+      # worker thread.
+      def flush
+        @lock.synchronize do
+          @flush += 1
+        end
+        begin
+          loop do
+            if @thread.nil? || !@thread.alive?
+              return
+            end
+
+            io_in_progress, queues_empty = @lock.synchronize do
+              [io_in_progress?, status_queue.empty? && snapshot_queue.empty?]
+            end
+
+            if io_in_progress
+              # If we just call Thread.pass we could be in a busy loop -
+              # add a sleep.
+              sleep 0.25
+              next
+            elsif queues_empty
+              break
+            else
+              wake.signal
+              sleep 0.25
+              next
+            end
+          end
+        ensure
+          @lock.synchronize do
+            @flush -= 1
+          end
+        end
+      end
+
+      private
+
+      attr_reader :wake
+      attr_reader :thread
+
+      # Convenience method to keep line length reasonable in the rest of the file.
+      def min_send_interval
+        settings.dynamic_instrumentation.internal.min_send_interval
+      end
+
+      # This method should be called while @lock is held.
+      def io_in_progress?
+        @io_in_progress
+      end
+
+      attr_reader :last_sent
+
+      def status_transport
+        @status_transport ||= DI::Transport::HTTP.diagnostics(agent_settings: agent_settings, logger: logger)
+      end
+
+      def do_send_status(batch)
+        status_transport.send_diagnostics(batch)
+      end
+
+      def snapshot_transport
+        @snapshot_transport ||= DI::Transport::HTTP.input(agent_settings: agent_settings, logger: logger)
+      end
+
+      def do_send_snapshot(batch)
+        snapshot_transport.send_input(batch, tags)
+      end
+
+      def tags
+        # DEV: The tags could be cached but they need to be recreated
+        # when process forks (since the child receives new runtime IDs).
+        Core::TagBuilder.tags(settings).merge(
+          'debugger_version' => Core::Environment::Identity.gem_datadog_version,
+        )
+      end
+
+      [
+        [:status, 'probe status'],
+        [:snapshot, 'snapshot'],
+      ].each do |(event_type, event_name)|
+        attr_reader "#{event_type}_queue"
+
+        # Adds a status or a snapshot to the queue to be sent to the agent
+        # at the next opportunity.
+        #
+        # If the queue is too large, the event will not be added.
+        #
+        # 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.
+        define_method("add_#{event_type}") do |event|
+          @lock.synchronize do
+            queue = send("#{event_type}_queue")
+            if queue.length > settings.dynamic_instrumentation.internal.snapshot_queue_capacity
+              logger.debug { "di: #{self.class.name}: dropping #{event_type} event because queue is full" }
+            else
+              logger.trace { "di: #{self.class.name}: queueing #{event_type} event" }
+              queue << event
+            end
+          end
+
+          # Figure out whether to wake up the worker thread.
+          # If minimum send interval has elapsed since the last send,
+          # wake up immediately.
+          @lock.synchronize do
+            unless @wake_scheduled
+              @wake_scheduled = true
+              set_sleep_remaining
+              wake.signal
+            end
+          end
+
+          # Worker could be not running if the process forked - check and
+          # start it again in this case.
+          start
+        end
+
+        public "add_#{event_type}"
+
+        # Sends pending probe statuses or snapshots.
+        #
+        # This method should ideally only be called when there are actually
+        # events to send, but it can be called when there is nothing to do.
+        # Currently we only have one wake-up signaling object and two
+        # types of events. Therefore on most wake-ups we expect to only
+        # send one type of events.
+        define_method("maybe_send_#{event_type}") do
+          batch = nil
+          @lock.synchronize do
+            batch = instance_variable_get("@#{event_type}_queue")
+            instance_variable_set("@#{event_type}_queue", [])
+            @io_in_progress = batch.any? # steep:ignore
+          end
+          logger.trace { "di: #{self.class.name}: checking #{event_type} queue - #{batch.length} entries" } # steep:ignore
+          if batch.any? # steep:ignore
+            begin
+              logger.trace { "di: sending #{batch.length} #{event_type} event(s) to agent" } # steep:ignore
+              send("do_send_#{event_type}", batch)
+              time = Core::Utils::Time.get_time
+              @lock.synchronize do
+                @last_sent = time
+              end
+            rescue => exc
+              raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions
+              logger.debug { "di: failed to send #{event_name}: #{exc.class}: #{exc} (at #{exc.backtrace.first})" }
+              # Should we report this error to telemetry? Most likely failure
+              # to send is due to a network issue, and trying to send a
+              # telemetry message would also fail.
+            end
+          end
+          batch.any? # steep:ignore
+        rescue ThreadError => exc
+          # Normally the queue should only be consumed in this method,
+          # however if anyone consumes it elsewhere we don't want to block
+          # while consuming it here. Rescue ThreadError and return.
+          logger.debug { "di: unexpected #{event_name} queue underflow - consumed elsewhere?" }
+          telemetry&.report(exc, description: "Unexpected #{event_name} queue underflow")
+        ensure
+          @lock.synchronize do
+            @io_in_progress = false
+          end
+        end
+      end
+
+      # Determine how much longer the worker thread should sleep
+      # so as not to send in less than min send interval since the last send.
+      # Important: this method must be called when @lock is held.
+      #
+      # Returns the time remaining to sleep.
+      def set_sleep_remaining
+        now = Core::Utils::Time.get_time
+        @sleep_remaining = if last_sent
+          [last_sent + min_send_interval - now, 0].max
+        else
+          0
+        end
+      end
+
+      def maybe_send
+        rv = maybe_send_status
+        maybe_send_snapshot || rv
+      end
+    end
+  end
+end

data/lib/datadog/di/proc_responder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Datadog
+  module DI
+    # An adapter to convert procs to responders.
+    #
+    # Used in test suite and benchmarks.
+    #
+    # @api private
+    class ProcResponder
+      def initialize(executed_proc, failed_proc = nil)
+        @executed_proc = executed_proc
+        @failed_proc = failed_proc
+      end
+
+      attr_reader :executed_proc
+      attr_reader :failed_proc
+
+      def probe_executed_callback(context)
+        executed_proc.call(context)
+      end
+
+      def probe_condition_evaluation_failed_callback(context, exc)
+        if failed_proc.nil?
+          raise NotImplementedError, "Failed proc not provided"
+        end
+
+        failed_proc.call(context, exc)
+      end
+    end
+  end
+end