datadog 2.23.0 → 2.25.0

data/lib/datadog/di/contrib/active_record.rb

@@ -1,12 +1,37 @@
 # frozen_string_literal: true
 
-Datadog::DI::Serializer.register(condition: lambda { |value| ActiveRecord::Base === value }) do |serializer, value, name:, depth:| # steep:ignore
-  # steep thinks all of the arguments are nil here
-  # steep:ignore:start
+Datadog::DI::Serializer.register(
+  # This serializer uses a dynamic condition to determine its applicability
+  # to a particular value. A simpler case could have been a serializer for
+  # a particular class, but in this case any ActiveRecord model is covered
+  # and they all have different classes.
+  #
+  # An alternative could have been to make DI specifically provide lookup
+  # logic for "instances of classes derived from X", but a condition Proc
+  # is more universal.
+  condition: lambda { |value| ActiveRecord::Base === value }
+) do |serializer, value, name:, depth:|
+  # +serializer+ is an instance of DI::Serializer.
+  # Use it to perform the serialization to primitive values.
+  #
+  # +value+ is the value to serialize. It should match the condition
+  # provided above, meaning it would be an ActiveRecord::Base instance.
+  #
+  # +name+ is the name of the (local/instance) variable being serialized.
+  # The name is used by DI for redaction (upstream of serialization logic),
+  # and could potentially be used for redaction here also.
+  #
+  # +depth+ is the remaining depth for serializing collections and objects.
+  # It should always be an integer.
+  # Reduce it by 1 when invoking +serialize_value+ on the contents of +value+.
+  # This serializer could also potentially do its own depth limiting.
+  #
+  # Steep: steep thinks all of the arguments are nil here
+  # Looks like it cannot handle kwargs in lambdas
+  # @type var depth: Integer
   value_to_serialize = {
     attributes: value.attributes,
     new_record: value.new_record?,
   }
-  serializer.serialize_value(value_to_serialize, depth: depth ? depth - 1 : nil, type: value.class)
-  # steep:ignore:end
+  serializer.serialize_value(value_to_serialize, depth: depth - 1, type: value.class)
 end

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

@@ -22,7 +22,8 @@ module Datadog
 
         private
 
-        OPERATORS = {
+        # Steep: https://github.com/soutaro/steep/issues/363
+        OPERATORS = { # steep:ignore IncompatibleAssignment
           'eq' => '==',
           'ne' => '!=',
           'ge' => '>=',
@@ -31,16 +32,19 @@ module Datadog
           'lt' => '<',
         }.freeze
 
+        # Steep: https://github.com/soutaro/steep/issues/363
         SINGLE_ARG_METHODS = %w[
           len isEmpty isUndefined
-        ].freeze
+        ].freeze # steep:ignore IncompatibleAssignment
 
+        # Steep: https://github.com/soutaro/steep/issues/363
         TWO_ARG_METHODS = %w[
           startsWith endsWith contains matches
           getmember index instanceof
-        ].freeze
+        ].freeze # steep:ignore IncompatibleAssignment
 
-        MULTI_ARG_METHODS = {
+        # Steep: https://github.com/soutaro/steep/issues/363
+        MULTI_ARG_METHODS = { # steep:ignore IncompatibleAssignment
           'and' => '&&',
           'or' => '||',
         }.freeze

data/lib/datadog/di/error.rb

@@ -42,6 +42,11 @@ module Datadog
       class ProbePreviouslyFailed < Error
       end
 
+      # Raised when trying to instrument a probe when there is existing
+      # instrumentation for the same probe id.
+      class AlreadyInstrumented < Error
+      end
+
       # Raised when installing a line probe and multiple files match the
       # specified path suffix.
       # A probe must be installed into one file only, since UI only

data/lib/datadog/di/instrumenter.rb

@@ -114,7 +114,9 @@ module Datadog
         settings = self.settings
 
         mod = Module.new do
-          define_method(method_name) do |*args, **kwargs, &target_block| # steep:ignore
+          define_method(method_name) do |*args, **kwargs, &target_block| # steep:ignore NoMethod
+            # Steep: Unsure why it cannot detect kwargs in this block. Workaround:
+            # @type var kwargs: ::Hash[::Symbol, untyped]
             continue = true
             if condition = probe.condition
               begin
@@ -166,7 +168,10 @@ module Datadog
                   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)
               end
-              start_time = Core::Utils::Time.get_time
+              # We intentionally do not use Core::Utils::Time.get_time
+              # here because the time provider may be overridden by the
+              # customer, and DI is not allowed to invoke customer code.
+              start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
               rv = nil
               begin
@@ -190,7 +195,7 @@ module Datadog
                 # the instrumentation callback runs.
               end
 
-              duration = Core::Utils::Time.get_time - start_time
+              duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
               # The method itself is not part of the stack trace because
               # we are getting the stack trace from outside of the method.
               # Add the method in manually as the top frame.
@@ -206,7 +211,8 @@ module Datadog
                 # that location here.
                 []
               end
-              caller_locs = method_frame + caller_locations # steep:ignore
+              # Steep: https://github.com/ruby/rbs/pull/2745
+              caller_locs = method_frame + caller_locations # steep:ignore ArgumentTypeMismatch
               # TODO capture arguments at exit
 
               context = Context.new(locals: nil, target_self: self,
@@ -256,6 +262,8 @@ module Datadog
 
           probe.instrumentation_module = mod
           cls.send(:prepend, mod)
+
+          DI.instrumented_count_inc(:method)
         end
       end
 
@@ -268,6 +276,8 @@ module Datadog
           if mod = probe.instrumentation_module
             mod.send(:remove_method, probe.method_name)
             probe.instrumentation_module = nil
+
+            DI.instrumented_count_dec(:method)
           end
         end
       end
@@ -298,7 +308,10 @@ module Datadog
 
         iseq = nil
         if code_tracker
-          ret = code_tracker.iseqs_for_path_suffix(probe.file) # steep:ignore
+          # Steep: Complex type narrowing (before calling hook_line,
+          # we check that probe.line? is true which itself checks that probe.file is not nil)
+          # Annotation do not work here as `file` is a method on probe, not a local variable.
+          ret = code_tracker.iseqs_for_path_suffix(probe.file) # steep:ignore ArgumentTypeMismatch
           unless ret
             if permit_untargeted_trace_points
               # Continue withoout targeting the trace point.
@@ -470,12 +483,16 @@ module Datadog
           # actual_path could be nil if we don't use targeted trace points.
           probe.instrumented_path = actual_path
 
-          if iseq
+          # TracePoint#enable returns false when it succeeds.
+          rv = if iseq
             tp.enable(target: iseq, target_line: line_no)
           else
             tp.enable
           end
-          # TracePoint#enable returns false when it succeeds.
+
+          DI.instrumented_count_inc(:line)
+
+          rv
         end
         true
       end
@@ -485,6 +502,8 @@ module Datadog
           if tp = probe.instrumentation_trace_point
             tp.disable
             probe.instrumentation_trace_point = nil
+
+            DI.instrumented_count_dec(:line)
           end
         end
       end

data/lib/datadog/di/logger.rb

@@ -8,7 +8,7 @@ module Datadog
     #
     # @api private
     class Logger
-      extend Forwardable # steep:ignore
+      extend Forwardable
 
       def initialize(settings, target)
         @settings = settings
@@ -18,7 +18,7 @@ module Datadog
       attr_reader :settings
       attr_reader :target
 
-      def_delegators :target, :debug # steep:ignore
+      def_delegators :target, :debug
 
       def trace(&block)
         if settings.dynamic_instrumentation.internal.trace_logging

data/lib/datadog/di/probe_builder.rb

@@ -20,7 +20,8 @@ module Datadog
     #
     # @api private
     module ProbeBuilder
-      PROBE_TYPES = {
+      # Steep: https://github.com/soutaro/steep/issues/363
+      PROBE_TYPES = { # steep:ignore IncompatibleAssignment
         'LOG_PROBE' => :log,
       }.freeze
 

data/lib/datadog/di/probe_file_loader/railtie.rb

@@ -6,7 +6,7 @@ module Datadog
       # Railtie class initializes dynamic instrumentation contrib code
       # in Rails environments.
       class Railtie < Rails::Railtie
-        initializer 'datadog.dynamic_instrumentation.load_probe_file' do |app| # steep:ignore
+        initializer 'datadog.dynamic_instrumentation.load_probe_file' do |app|
           ProbeFileLoader.load_now
         end
       end

data/lib/datadog/di/probe_manager.rb

@@ -94,6 +94,19 @@ module Datadog
       # matches.
       def add_probe(probe)
         @lock.synchronize do
+          if @installed_probes[probe.id]
+            # Either this probe was already installed, or another probe was
+            # installed with the same id (previous version perhaps?).
+            # Since our state tracking is keyed by probe id, we cannot
+            # install this probe since we won't have a way of removing the
+            # instrumentation for the probe with the same id which is already
+            # installed.
+            #
+            # The exception raised here will be caught below and logged and
+            # reported to telemetry.
+            raise Error::AlreadyInstrumented, "Probe with id #{probe.id} is already in installed probes"
+          end
+
           # Probe failed to install previously, do not try to install it again.
           if msg = @failed_probes[probe.id]
             # TODO test this path
@@ -134,38 +147,30 @@ module Datadog
         end
       end
 
-      # Removes probes with ids other than in the specified list.
-      #
-      # This method is meant to be invoked from remote config processor.
-      # Remote config contains the list of currently defined probes; any
-      # probes not in that list have been removed by user and should be
-      # de-instrumented from the application.
-      def remove_other_probes(probe_ids)
+      # Removes probe with specified id. The probe could be pending or
+      # installed. Does nothing if there is no probe with the specified id.
+      def remove_probe(probe_id)
         @lock.synchronize do
-          @pending_probes.values.each do |probe|
-            unless probe_ids.include?(probe.id)
-              @pending_probes.delete(probe.id)
-            end
-          end
-          @installed_probes.values.each do |probe|
-            unless probe_ids.include?(probe.id)
-              begin
-                instrumenter.unhook(probe)
-                # Only remove the probe from installed list if it was
-                # successfully de-instrumented. Active probes do incur overhead
-                # for the running application, and if the error is ephemeral
-                # we want to try removing the probe again at the next opportunity.
-                #
-                # TODO give up after some time?
-                @installed_probes.delete(probe.id)
-              rescue => exc
-                raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions
-                # Silence all exceptions?
-                # TODO should we propagate here and rescue upstream?
-                logger.debug { "di: error removing #{probe.type} probe at #{probe.location} (#{probe.id}): #{exc.class}: #{exc}" }
-                telemetry&.report(exc, description: "Error removing probe")
-              end
-            end
+          @pending_probes.delete(probe_id)
+        end
+
+        # Do not delete the probe from the registry here in case
+        # deinstrumentation fails - though I don't know why deinstrumentation
+        # would fail and how we could recover if it does.
+        # I plan on tracking the number of outstanding (instrumented) probes
+        # in the future, and if deinstrumentation fails I would want to
+        # keep that probe as "installed" for the count, so that we can
+        # investigate the situation.
+        if probe = @installed_probes[probe_id]
+          begin
+            instrumenter.unhook(probe)
+            @installed_probes.delete(probe_id)
+          rescue => exc
+            raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions
+            # Silence all exceptions?
+            # TODO should we propagate here and rescue upstream?
+            logger.debug { "di: error removing #{probe.type} probe at #{probe.location} (#{probe.id}): #{exc.class}: #{exc}" }
+            telemetry&.report(exc, description: "Error removing probe")
           end
         end
       end
@@ -185,6 +190,7 @@ module Datadog
                   # TODO is it OK to hook from trace point handler?
                   # TODO the class is now defined, but can hooking still fail?
                   instrumenter.hook(probe, self)
+                  @installed_probes[probe.id] = probe
                   @pending_probes.delete(probe.id)
                   break
                 rescue Error::DITargetNotDefined

data/lib/datadog/di/probe_notification_builder.rb

@@ -46,7 +46,7 @@ module Datadog
         build_snapshot(context)
       end
 
-      NANOSECONDS = 10**9
+      NANOSECONDS = 1_000_000_000
       MILLISECONDS = 1000
 
       def build_snapshot(context)
@@ -134,7 +134,7 @@ module Datadog
           format_caller_locations(caller_locations)
         end
 
-        {
+        payload = {
           service: settings.service,
           debugger: {
             type: 'snapshot',
@@ -189,6 +189,10 @@ module Datadog
           message: message,
           timestamp: timestamp,
         }
+
+        tag_process_tags!(payload, settings)
+
+        payload
       end
 
       def build_status(probe, message:, status:)
@@ -236,6 +240,15 @@ module Datadog
         [message, evaluation_errors]
       end
 
+      def tag_process_tags!(payload, settings)
+        return unless settings.experimental_propagate_process_tags_enabled
+
+        process_tags = Core::Environment::Process.serialized
+        return if process_tags.empty?
+
+        payload[:process_tags] = process_tags
+      end
+
       def timestamp_now
         (Core::Utils::Time.now.to_f * MILLISECONDS).to_i
       end

data/lib/datadog/di/probe_notifier_worker.rb

@@ -249,12 +249,12 @@ module Datadog
           @lock.synchronize do
             batch = instance_variable_get("@#{event_type}_queue")
             instance_variable_set("@#{event_type}_queue", [])
-            @io_in_progress = batch.any? # steep:ignore
+            @io_in_progress = batch.any?
           end
-          logger.trace { "di: #{self.class.name}: checking #{event_type} queue - #{batch.length} entries" } # steep:ignore
-          if batch.any? # steep:ignore
+          logger.trace { "di: #{self.class.name}: checking #{event_type} queue - #{batch.length} entries" }
+          if batch.any?
             begin
-              logger.trace { "di: sending #{batch.length} #{event_type} event(s) to agent" } # steep:ignore
+              logger.trace { "di: sending #{batch.length} #{event_type} event(s) to agent" }
               send("do_send_#{event_type}", batch)
               time = Core::Utils::Time.get_time
               @lock.synchronize do
@@ -268,7 +268,7 @@ module Datadog
               # telemetry message would also fail.
             end
           end
-          batch.any? # steep:ignore
+          batch.any?
         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

data/lib/datadog/di/remote.rb

@@ -12,8 +12,6 @@ module Datadog
     #
     # @api private
     module Remote
-      class ReadError < StandardError; end
-
       class << self
         PRODUCT = 'LIVE_DEBUGGING'
 
@@ -28,7 +26,7 @@ module Datadog
         end
 
         def receivers(telemetry)
-          receiver do |repository, _changes|
+          receiver do |repository, changes|
             # DEV: Filter our by product. Given it will be very common
             # DEV: we can filter this out before we receive the data in this method.
             # DEV: Apply this refactor to AppSec as well if implemented.
@@ -41,84 +39,23 @@ module Datadog
             # If the component is nil for some reason, we also don't have a
             # logger instance to report the issue.
             if component
-
-              probe_manager = component.probe_manager
-              probe_notification_builder = component.probe_notification_builder
-              probe_notifier_worker = component.probe_notifier_worker
-
-              current_probe_ids = {}
-              repository.contents.each do |content|
-                case content.path.product
-                when PRODUCT
-                  begin
-                    probe_spec = parse_content(content)
-                    probe = component.parse_probe_spec_and_notify(probe_spec)
-                    component.logger.debug { "di: received #{probe.type} probe at #{probe.location} (#{probe.id}) via RC" }
-
-                    begin
-                      # TODO test exception capture
-                      probe_manager.add_probe(probe)
-                      content.applied
-                    rescue DI::Error::DITargetNotInRegistry => exc
-                      component.telemetry&.report(exc, description: "Line probe is targeting a loaded file that is not in code tracker")
-
-                      payload = probe_notification_builder.build_errored(probe, exc)
-                      probe_notifier_worker.add_status(payload)
-
-                      # If a probe fails to install, we will mark the content
-                      # as errored. On subsequent remote configuration application
-                      # attemps, probe manager will raise the "previously errored"
-                      # exception and we'll rescue it here, again marking the
-                      # content as errored but with a somewhat different exception
-                      # message.
-                      # TODO assert content state (errored for this example)
-                      content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
-                    rescue => exc
-                      raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
-
-                      component.logger.debug { "di: unhandled exception adding #{probe.type} probe at #{probe.location} (#{probe.id}) in DI remote receiver: #{exc.class}: #{exc}" }
-                      component.telemetry&.report(exc, description: "Unhandled exception adding probe in DI remote receiver")
-
-                      # TODO test this path
-                      payload = probe_notification_builder.build_errored(probe, exc)
-                      probe_notifier_worker.add_status(payload)
-
-                      # If a probe fails to install, we will mark the content
-                      # as errored. On subsequent remote configuration application
-                      # attemps, probe manager will raise the "previously errored"
-                      # exception and we'll rescue it here, again marking the
-                      # content as errored but with a somewhat different exception
-                      # message.
-                      # TODO assert content state (errored for this example)
-                      content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
-                    end
-
-                    # Important: even if processing fails for this probe config,
-                    # 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
-                  rescue => exc
-                    raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
-
-                    component.logger.debug { "di: unhandled exception handling a probe in DI remote receiver: #{exc.class}: #{exc}" }
-                    component.telemetry&.report(exc, description: "Unhandled exception handling probe in DI remote receiver")
-
-                    # TODO assert content state (errored for this example)
-                    content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
-                  end
+              changes.each do |change|
+                case change.type
+                when :insert
+                  add_probe(change.content, component)
+                when :update
+                  # We do not implement updates at the moment, remove the
+                  # probe and reinstall.
+                  remove_probe(change.content, component)
+                  add_probe(change.content, component)
+                when :delete
+                  remove_probe(change.previous, component)
+                else
+                  # This really should never happen since we generate the
+                  # change types in the library.
+                  component.logger.debug { "di: unrecognized change type: #{change.type}" }
                 end
               end
-
-              begin
-                # TODO test exception capture
-                probe_manager.remove_other_probes(current_probe_ids.keys)
-              rescue => exc
-                raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
-
-                component.logger.debug { "di: unhandled exception removing probes in DI remote receiver: #{exc.class}: #{exc}" }
-                component.telemetry&.report(exc, description: "Unhandled exception removing probes in DI remote receiver")
-              end
             end
           end
         end
@@ -130,14 +67,82 @@ module Datadog
 
         private
 
-        def parse_content(content)
-          data = content.data.read
+        def add_probe(content, component)
+          probe_spec = parse_content(content)
+          probe = component.parse_probe_spec_and_notify(probe_spec)
+          component.logger.debug { "di: received #{probe.type} probe at #{probe.location} (#{probe.id}) via RC" }
+
+          begin
+            # TODO test exception capture
+            component.probe_manager.add_probe(probe)
+            content.applied
+          rescue DI::Error::DITargetNotInRegistry => exc
+            component.telemetry&.report(exc, description: "Line probe is targeting a loaded file that is not in code tracker")
+
+            payload = component.probe_notification_builder.build_errored(probe, exc)
+            component.probe_notifier_worker.add_status(payload)
+
+            # If a probe fails to install, we will mark the content
+            # as errored. On subsequent remote configuration application
+            # attemps, probe manager will raise the "previously errored"
+            # exception and we'll rescue it here, again marking the
+            # content as errored but with a somewhat different exception
+            # message.
+            # TODO assert content state (errored for this example)
+            content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
+          rescue => exc
+            raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
+
+            component.logger.debug { "di: unhandled exception adding #{probe.type} probe at #{probe.location} (#{probe.id}) in DI remote receiver: #{exc.class}: #{exc}" }
+            component.telemetry&.report(exc, description: "Unhandled exception adding probe in DI remote receiver")
+
+            # TODO test this path
+            payload = component.probe_notification_builder.build_errored(probe, exc)
+            component.probe_notifier_worker.add_status(payload)
+
+            # If a probe fails to install, we will mark the content
+            # as errored. On subsequent remote configuration application
+            # attemps, probe manager will raise the "previously errored"
+            # exception and we'll rescue it here, again marking the
+            # content as errored but with a somewhat different exception
+            # message.
+            # TODO assert content state (errored for this example)
+            content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
+          end
+
+          # Important: even if processing fails for this probe config,
+          # 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
+        rescue => exc
+          raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
+
+          component.logger.debug { "di: unhandled exception handling a probe in DI remote receiver: #{exc.class}: #{exc}" }
+          component.telemetry&.report(exc, description: "Unhandled exception handling probe in DI remote receiver")
 
-          content.data.rewind
+          # TODO assert content state (errored for this example)
+          content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
+        end
 
-          raise ReadError, 'EOF reached' if data.nil?
+        # This method does not mark +previous_content+ as succeeded or errored,
+        # because that content is from a previous RC response and has already
+        # been marked. Removal of probes happens when an RC entry disappears,
+        # as such there is nothing to mark.
+        def remove_probe(previous_content, component)
+          # TODO test exception capture
+          probe_spec = parse_content(previous_content)
+          probe_id = probe_spec.fetch('id')
+          component.probe_manager.remove_probe(probe_id)
+        rescue => exc
+          raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
+
+          component.logger.debug { "di: unhandled exception removing probes in DI remote receiver: #{exc.class}: #{exc}" }
+          component.telemetry&.report(exc, description: "Unhandled exception removing probes in DI remote receiver")
+        end
 
-          JSON.parse(data)
+        def parse_content(content)
+          JSON.parse(content.data)
         end
       end
     end

data/lib/datadog/di/transport/diagnostics.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
+require 'json'
+
 require_relative '../../core/transport/parcel'
+require_relative '../../core/transport/request'
+require_relative '../../core/transport/transport'
 require_relative 'http/diagnostics'
 
 module Datadog
@@ -14,46 +18,14 @@ module Datadog
         class Request < Datadog::Core::Transport::Request
         end
 
-        class Transport
-          attr_reader :client, :apis, :default_api, :current_api_id, :logger
-
-          def initialize(apis, default_api, logger:)
-            @apis = apis
-            @logger = logger
-
-            @client = DI::Transport::HTTP::Diagnostics::Client.new(current_api, logger: logger)
-          end
-
-          def current_api
-            @apis[HTTP::API::DIAGNOSTICS]
-          end
-
+        class Transport < Core::Transport::Transport
           def send_diagnostics(payload)
+            # TODO use transport encoder functionality?
             json = JSON.dump(payload)
             parcel = EncodedParcel.new(json)
             request = Request.new(parcel)
 
-            response = @client.send_diagnostics_payload(request)
-            unless response.ok?
-              # TODO Datadog::Core::Transport::InternalErrorResponse
-              # does not have +code+ method, what is the actual API of
-              # these response objects?
-              raise Error::AgentCommunicationError, "send_diagnostics failed: #{begin
-                response.code
-              rescue
-                "???"
-              end}: #{response.payload}"
-            end
-          rescue Error::AgentCommunicationError
-            raise
-          # Datadog::Core::Transport does not perform any exception mapping,
-          # therefore we could have any exception here from failure to parse
-          # agent URI for example.
-          # If we ever implement retries for network errors, we should distinguish
-          # actual network errors from non-network errors that are raised by
-          # transport code.
-          rescue => exc
-            raise Error::AgentCommunicationError, "send_diagnostics failed: #{exc.class}: #{exc}"
+            client.send_request(:diagnostics, request)
           end
         end
       end