datadog 2.29.0 → 2.31.0

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

@@ -52,9 +52,10 @@ module Datadog
         def self.input(
           agent_settings:,
           logger:,
-          headers: nil
+          headers: nil,
+          telemetry: nil
         )
-          Core::Transport::HTTP.build(
+          builder = Core::Transport::HTTP.build(
             logger: logger,
             agent_settings: agent_settings,
             headers: headers,
@@ -64,7 +65,15 @@ module Datadog
 
             # Call block to apply any customization, if provided
             yield(transport) if block_given?
-          end.to_transport(DI::Transport::Input::Transport)
+          end
+
+          # Create transport with telemetry
+          DI::Transport::Input::Transport.new(
+            builder.to_api_instances,
+            builder.default_api,
+            logger: logger,
+            telemetry: telemetry
+          )
         end
       end
     end

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

@@ -24,6 +24,13 @@ module Datadog
         end
 
         class Transport < Core::Transport::Transport
+          attr_reader :telemetry
+
+          def initialize(apis, default_api, logger:, telemetry: nil)
+            super(apis, default_api, logger: logger)
+            @telemetry = telemetry
+          end
+
           # The limit on an individual snapshot payload, aka "log line",
           # is 1 MB.
           #
@@ -43,22 +50,52 @@ module Datadog
           # max chunk size, it will still get sent out.
           DEFAULT_CHUNK_SIZE = 2 * 1024 * 1024
 
-          def send_input(payload, tags)
-            # Tags are the same for all chunks, serialize them one time.
+          # Sends snapshot payloads to the agent.
+          #
+          # Each snapshot is serialized individually. If serialization fails
+          # for a snapshot (e.g., due to binary data from custom serializers),
+          # the on_serialization_error callback is invoked with the probe ID
+          # and exception, allowing the caller to disable the affected probe.
+          # Successfully serialized snapshots are still sent.
+          #
+          # Large snapshots (> 1MB) are dropped. Batches are split into chunks
+          # of ~2MB each to avoid large network requests.
+          #
+          # @param payload [Array<Hash>] Array of snapshot payloads
+          # @param tags [Hash] Tags to send with the snapshots
+          # @param on_serialization_error [Proc] Called with (probe_id, exception)
+          #   when a snapshot fails to serialize.
+          def send_input(payload, tags, on_serialization_error:)
             serialized_tags = Core::TagBuilder.serialize_tags(tags)
 
-            encoded_snapshots = Core::Utils::Array.filter_map(payload) do |snapshot|
+            # Serialize each snapshot individually to isolate failures
+            encoded_snapshots = []
+            payload.each do |snapshot|
               encoded = encoder.encode(snapshot)
               if encoded.length > MAX_SERIALIZED_SNAPSHOT_SIZE
-                # Drop the snapshot.
-                # TODO report via telemetry metric?
                 logger.debug { "di: dropping too big snapshot" }
-                nil
-              else
-                encoded
+                next
+              end
+              encoded_snapshots << encoded
+            rescue => exc
+              # Serialization failed for this snapshot - report via callback
+              # This catches JSON::GeneratorError, Encoding errors, TypeError, etc.
+              probe_id = snapshot.dig(:debugger, :snapshot, :probe, :id)
+              logger.debug { "di: JSON encoding failed for snapshot (probe #{probe_id}): #{exc.class}: #{exc}" }
+              telemetry&.report(exc, description: "JSON encoding failed for snapshot")
+
+              if probe_id
+                begin
+                  on_serialization_error.call(probe_id, exc)
+                rescue => callback_exc
+                  logger.debug { "di: error in serialization error callback for probe #{probe_id}: #{callback_exc.class}: #{callback_exc}" }
+                  telemetry&.report(callback_exc, description: "Error in serialization error callback")
+                end
               end
             end
 
+            return payload if encoded_snapshots.empty?
+
             Datadog::Core::Chunker.chunk_by_size(
               encoded_snapshots, DEFAULT_CHUNK_SIZE,
             ).each do |chunk|
@@ -74,6 +111,7 @@ module Datadog
                 send_input_chunk(chunked_payload, serialized_tags)
               rescue => exc
                 logger.debug { "di: failed to send snapshot chunk: #{exc.class}: #{exc} (at #{exc.backtrace.first})" }
+                telemetry&.report(exc, description: "Error sending snapshot chunk")
               end
             end
 

data/lib/datadog/di.rb

@@ -11,11 +11,92 @@ module Datadog
   module DI
     INSTRUMENTED_COUNTERS_LOCK = Mutex.new
 
+    # Captured at load time from Exception itself (not a subclass).
+    # Used to bypass subclass overrides of backtrace_locations.
+    #
+    # This does NOT protect against monkeypatching Exception#backtrace_locations
+    # before dd-trace-rb loads — in that case we'd capture the monkeypatch.
+    # The practical threat model is customer subclasses overriding the method:
+    #
+    #   class MyError < StandardError
+    #     def backtrace_locations; []; end
+    #   end
+    #
+    # The UnboundMethod bypasses subclass overrides: bind(exception).call
+    # always dispatches to the original Exception implementation.
+    #
+    # Note: if the subclass overrides #backtrace (not #backtrace_locations),
+    # MRI's setup_exception skips storing the VM backtrace entirely — both
+    # @bt and @bt_locations stay nil. In that case this UnboundMethod also
+    # returns nil. See EXCEPTION_BACKTRACE comment for details.
+    EXCEPTION_BACKTRACE_LOCATIONS = Exception.instance_method(:backtrace_locations)
+
+    # Same UnboundMethod trick for Exception#backtrace (Array<String>).
+    # Used as a fallback when backtrace_locations returns nil — which happens
+    # when someone calls Exception#set_backtrace with an Array<String>.
+    #
+    # set_backtrace accepts Array<String> or nil. When called with strings,
+    # it replaces the VM-level backtrace: backtrace returns the new strings,
+    # but backtrace_locations returns nil because the VM cannot reconstruct
+    # Location objects from formatted strings. This occurs in exception
+    # wrapping patterns where a library catches an exception, creates a new
+    # one, and copies the original's string backtrace onto it via
+    # set_backtrace before re-raising.
+    #
+    # Ruby 3.4+ also allows set_backtrace(Array<Location>), which preserves
+    # backtrace_locations — but older Rubies and most existing code use
+    # the string form.
+    #
+    # Like EXCEPTION_BACKTRACE_LOCATIONS, this UnboundMethod bypasses
+    # subclass overrides of #backtrace: bind(exception).call dispatches
+    # to Exception#backtrace regardless of what the subclass defines.
+    #
+    # However, when a subclass overrides #backtrace, MRI's setup_exception
+    # (eval.c) calls the override via rb_get_backtrace during raise. If it
+    # gets a non-nil result, it skips storing the VM backtrace in @bt and
+    # @bt_locations entirely. So the UnboundMethod bypasses the override
+    # at dispatch but reads nil from @bt because the data was never stored.
+    #
+    # This constant is used as a fallback when backtrace_locations returns
+    # nil. In the common set_backtrace-with-strings case, no subclass
+    # override is involved and the fallback works. The only unrecoverable
+    # case: a subclass overrides #backtrace, the exception is raised
+    # normally, and set_backtrace is never called. Both @bt and
+    # @bt_locations are nil — DI reports an empty stacktrace (type and
+    # message are still reported).
+    EXCEPTION_BACKTRACE = Exception.instance_method(:backtrace)
+
     class << self
       def enabled?
         Datadog.configuration.dynamic_instrumentation.enabled
       end
 
+      # Returns iseqs that correspond to loaded files (filtering out eval'd code).
+      #
+      # There are several types of iseqs returned by +all_iseqs+:
+      #
+      # 1. Eval'd code — these have a nil +absolute_path+ and are filtered out here.
+      # 2. Whole-file iseqs — have +absolute_path+ set and +first_lineno+ of 0.
+      #    Only available for a subset of loaded files (the full-file iseq may be
+      #    garbage collected after loading completes). Easiest to work with since
+      #    we just match the file path to the probe specification.
+      # 3. Per-method iseqs — have +absolute_path+ set and +first_lineno+ > 0.
+      #    Often the only iseqs available for third-party code. Require identifying
+      #    the correct iseq containing the target line, which may involve examining
+      #    the iseq's +trace_points+ since +define_method+ can create nested,
+      #    non-contiguous line ranges.
+      #
+      # Note: the same line of code can appear in multiple iseqs (e.g. when
+      # +define_method+ is used inside a method). DI treats this as an error
+      # since a probe must resolve to exactly one code location.
+      #
+      # @return [Array<RubyVM::InstructionSequence>] iseqs with non-nil +absolute_path+
+      def file_iseqs
+        all_iseqs.select do |iseq|
+          iseq.absolute_path
+        end
+      end
+
       # This method is called from DI Remote handler to issue DI operations
       # to the probe manager (add or remove probes).
       #

data/lib/datadog/kit/enable_core_dumps.rb

@@ -30,7 +30,7 @@ module Datadog
           Process.setrlimit(:CORE, maximum_size)
         rescue => e
           Kernel.warn(
-            "[datadog] Failed to enable core dumps. Cause: #{e.class.name} #{e.message} " \
+            "[datadog] Failed to enable core dumps. Cause: #{e.class}: #{e} " \
             "Location: #{Array(e.backtrace).first}"
           )
           return

data/lib/datadog/open_feature/configuration.rb

@@ -12,6 +12,8 @@ module Datadog
 
         def self.add_settings!(base)
           base.class_eval do
+            # Steep does not update `self` for this `class_eval` block.
+            # @type self: Datadog::Core::Configuration::Base::_DslContext
             settings :open_feature do
               option :enabled do |o|
                 o.type :bool

data/lib/datadog/open_feature/evaluation_engine.rb

@@ -60,7 +60,7 @@ module Datadog
       rescue => e
         message = 'OpenFeature: Failed to reconfigure, reverting to the previous configuration'
 
-        @logger.error("#{message}, #{e.class}: #{e.message}")
+        @logger.error("#{message}, #{e.class}: #{e}")
         @telemetry.report(e, description: "#{message} (#{e.class})")
 
         raise ReconfigurationError, e.message

data/lib/datadog/open_feature/exposures/reporter.rb

@@ -29,7 +29,7 @@ module Datadog
           event = Event.build(result, flag_key: flag_key, context: context)
           @worker.enqueue(event)
         rescue => e
-          @logger.debug { "OpenFeature: Failed to report resolution details: #{e.class}: #{e.message}" }
+          @logger.debug { "OpenFeature: Failed to report resolution details: #{e.class}: #{e}" }
           @telemetry.report(e, description: 'OpenFeature: Failed to report resolution details')
 
           false

data/lib/datadog/open_feature/exposures/worker.rb

@@ -105,7 +105,7 @@ module Datadog
 
           response
         rescue => e
-          @logger.debug { "OpenFeature: Failed to flush resolution details events: #{e.class}: #{e.message}" }
+          @logger.debug { "OpenFeature: Failed to flush resolution details events: #{e.class}: #{e}" }
           @telemetry.report(e, description: 'OpenFeature: Failed to flush resolution details events')
 
           nil

data/lib/datadog/open_feature/remote.rb

@@ -41,7 +41,7 @@ module Datadog
                   engine.reconfigure!(read_content(content))
                   content.applied
                 rescue EvaluationEngine::ReconfigurationError => e
-                  content.errored("Error applying OpenFeature configuration: #{e.message}")
+                  content.errored("Error applying OpenFeature configuration: #{e.class}: #{e}")
                 end
               when :delete
                 # NOTE: For now, we treat deletion as clearing the configuration

data/lib/datadog/open_feature/transport.rb

@@ -55,7 +55,7 @@ module Datadog
             @api.call(env)
           end
         rescue => e
-          message = "Internal error during request. Cause: #{e.class.name} #{e.message} " \
+          message = "Internal error during request. Cause: #{e.class}: #{e} " \
                     "Location: #{Array(e.backtrace).first}"
           @logger.debug(message)
 

data/lib/datadog/opentelemetry/configuration/settings.rb

@@ -76,6 +76,7 @@ module Datadog
                 end
 
                 option :headers do |o|
+                  o.skip_telemetry true
                   o.type :hash
                   o.env 'OTEL_EXPORTER_OTLP_HEADERS'
                   o.default { {} }
@@ -131,6 +132,7 @@ module Datadog
                 end
 
                 option :headers do |o|
+                  o.skip_telemetry true
                   o.type :hash, nilable: true
                   o.env 'OTEL_EXPORTER_OTLP_METRICS_HEADERS'
                   o.default nil

data/lib/datadog/profiling/collectors/code_provenance.rb

@@ -135,7 +135,7 @@ module Datadog
         rescue Exception => e # rubocop:disable Lint/RescueException
           Datadog.logger.debug(
             "CodeProvenance#bundler_bin_path failed. " \
-            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+            "Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
           )
           nil
         end
@@ -161,8 +161,7 @@ module Datadog
           end
 
           def to_json(arg = nil)
-            # Steep: https://github.com/ruby/rbs/pull/2691 (remove after RBS 4.0 release)
-            {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg) # steep:ignore ArgumentTypeMismatch
+            {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg)
           end
 
           def path

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -24,6 +24,7 @@ module Datadog
           allocation_counting_enabled:,
           gvl_profiling_enabled:,
           sighandler_sampling_enabled:,
+          cpu_sampling_interval_ms:,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
@@ -39,6 +40,10 @@ module Datadog
             )
           end
 
+          if cpu_sampling_interval_ms < 1
+            raise ArgumentError, "cpu_sampling_interval_ms must be a positive integer, got #{cpu_sampling_interval_ms}"
+          end
+
           self.class._native_initialize(
             self_instance: self,
             thread_context_collector: thread_context_collector,
@@ -52,6 +57,7 @@ module Datadog
             gvl_profiling_enabled: gvl_profiling_enabled,
             sighandler_sampling_enabled: sighandler_sampling_enabled,
             skip_idle_samples_for_testing: skip_idle_samples_for_testing,
+            cpu_sampling_interval_ms: cpu_sampling_interval_ms,
           )
           @worker_thread = nil
           @failure_exception = nil
@@ -75,12 +81,19 @@ module Datadog
               self.class._native_sampling_loop(self)
 
               Datadog.logger.debug("CpuAndWallTimeWorker thread stopping cleanly")
+            rescue Profiling::ExistingSignalHandler => e
+              @failure_exception = e
+              Datadog.logger.warn(
+                "Profiling was not started as another profiler or gem is already using the SIGPROF signal. " \
+                "Please disable the other profiler to use Datadog profiling."
+              )
+              on_failure_proc&.call(log_failure: false)
             rescue Exception => e # rubocop:disable Lint/RescueException
               @failure_exception = e
               operation_name = self.class._native_failure_exception_during_operation(self).inspect
               Datadog.logger.warn(
                 "CpuAndWallTimeWorker thread error. " \
-                "Operation: #{operation_name} Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+                "Operation: #{operation_name} Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
               )
               on_failure_proc&.call
               Datadog::Core::Telemetry::Logger.report(e, description: "CpuAndWallTimeWorker thread error: #{operation_name}")

data/lib/datadog/profiling/collectors/idle_sampling_helper.rb

@@ -39,7 +39,7 @@ module Datadog
               @failure_exception = e
               Datadog.logger.warn(
                 "IdleSamplingHelper thread error. " \
-                "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+                "Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
               )
               Datadog::Core::Telemetry::Logger.report(e, description: "IdleSamplingHelper thread error")
             end

data/lib/datadog/profiling/component.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../core/telemetry/logger"
+
 module Datadog
   module Profiling
     # Responsible for wiring up the Profiler for execution
@@ -45,6 +47,8 @@ module Datadog
 
         overhead_target_percentage = valid_overhead_target(settings.profiling.advanced.overhead_target_percentage, logger)
         upload_period_seconds = [60, settings.profiling.advanced.upload_period_seconds].max
+        cpu_sampling_interval_ms =
+          valid_cpu_sampling_interval(settings.profiling.advanced.experimental_cpu_sampling_interval_ms, logger)
 
         recorder = Datadog::Profiling::StackRecorder.new(
           cpu_time_enabled: RUBY_PLATFORM.include?("linux"), # Only supported on Linux currently
@@ -65,6 +69,7 @@ module Datadog
           allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
           gvl_profiling_enabled: enable_gvl_profiling?(settings, logger),
           sighandler_sampling_enabled: settings.profiling.advanced.sighandler_sampling_enabled,
+          cpu_sampling_interval_ms: cpu_sampling_interval_ms,
         )
 
         internal_metadata = {
@@ -87,6 +92,14 @@ module Datadog
         end
 
         [profiler, {profiling_enabled: true}]
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        logger.warn do
+          "Failed to initialize profiling: #{e.class}: #{e} " \
+          "Location: #{Array(e.backtrace).first}"
+        end
+        Datadog::Core::Telemetry::Logger.report(e, description: "Failed to initialize profiling")
+
+        [nil, {profiling_enabled: false}]
       end
 
       private_class_method def self.build_thread_context_collector(settings, recorder, optional_tracer, timeline_enabled)
@@ -123,6 +136,7 @@ module Datadog
             site: settings.site,
             api_key: settings.api_key,
             upload_timeout_seconds: settings.profiling.upload.timeout_seconds,
+            use_system_dns: settings.profiling.advanced.experimental_use_system_dns,
           )
       end
 
@@ -364,7 +378,7 @@ module Datadog
         rescue StandardError, LoadError => e
           logger.warn(
             "Failed to probe `mysql2` gem information. " \
-            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+            "Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
           )
 
           true
@@ -397,6 +411,22 @@ module Datadog
         end
       end
 
+      private_class_method def self.valid_cpu_sampling_interval(cpu_sampling_interval_ms, logger)
+        if cpu_sampling_interval_ms > 10
+          logger.warn(
+            "Profiling cpu_sampling_interval_ms is set to #{cpu_sampling_interval_ms}ms, but values above 10ms are " \
+            "not supported. Using 10ms instead. To reduce profiler overhead, consider adjusting the " \
+            "overhead_target_percentage setting."
+          )
+          10
+        elsif cpu_sampling_interval_ms < 10
+          logger.debug { "Profiling cpu_sampling_interval_ms set to #{cpu_sampling_interval_ms}ms" }
+          cpu_sampling_interval_ms
+        else
+          cpu_sampling_interval_ms
+        end
+      end
+
       # To add just a bit more complexity to our detection code, in https://github.com/DataDog/dd-trace-rb/issues/3334
       # a user reported that our code was incorrectly flagging the mariadb variant of libmysqlclient as being
       # incompatible. In fact we have no reports of the mariadb variant needing the "no signals" workaround,

data/lib/datadog/profiling/http_transport.rb

@@ -10,17 +10,17 @@ module Datadog
     class HttpTransport
       attr_reader :exporter_configuration
 
-      def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:)
-        @upload_timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
+      def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:, use_system_dns:)
+        timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
 
         # Steep: multiple issues here
         # first https://github.com/soutaro/steep/issues/363
         # then https://github.com/soutaro/steep/issues/1603 (remove the .freeze to see it)
         @exporter_configuration = # steep:ignore IncompatibleAssignment
           if agentless?(site, api_key)
-            [:agentless, site, api_key].freeze
+            [:agentless, timeout_milliseconds, use_system_dns, site, api_key].freeze
           else
-            [:agent, agent_settings.url].freeze
+            [:agent, timeout_milliseconds, use_system_dns, agent_settings.url].freeze
           end
 
         status, result = self.class._native_validate_exporter(exporter_configuration)
@@ -31,7 +31,6 @@ module Datadog
       def export(flush)
         status, result = self.class._native_do_export(
           exporter_configuration,
-          @upload_timeout_milliseconds,
           flush
         )
 
@@ -63,7 +62,7 @@ module Datadog
       end
 
       def config_without_api_key
-        "#{exporter_configuration[0]}: #{exporter_configuration[1]}"
+        "#{exporter_configuration[0]}: #{exporter_configuration[3]}"
       end
     end
   end

data/lib/datadog/profiling/load_native_extension.rb

@@ -4,6 +4,6 @@ begin
   require "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
 rescue LoadError => e
   raise LoadError,
-    "Failed to load the profiling loader extension. To fix this, please remove and then reinstall datadog " \
+    "Failed to load the profiling native extension. To fix this, please remove and then reinstall datadog " \
     "(Details: #{e.message})"
 end

data/lib/datadog/profiling/profiler.rb

@@ -17,17 +17,18 @@ module Datadog
         @scheduler = scheduler
       end
 
-      def enabled?
-        scheduler.running?
-      end
-
       def start
         after_fork! do
           worker.reset_after_fork
           scheduler.reset_after_fork
         end
 
-        worker.start(on_failure_proc: proc { component_failed(:worker) })
+        worker.start(
+          on_failure_proc: ->(log_failure: true) do
+            # @type var log_failure: bool
+            component_failed(:worker, log_failure: log_failure)
+          end
+        )
         scheduler.start(on_failure_proc: proc { component_failed(:scheduler) })
       end
 
@@ -50,13 +51,15 @@ module Datadog
         scheduler.stop(true)
       end
 
-      def component_failed(failed_component)
-        Datadog.logger.warn(
-          "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
-          "See previous log messages for details."
-        )
-        Datadog::Core::Telemetry::Logger
-          .error("Detected issue with profiler (#{failed_component} component), stopping profiling")
+      def component_failed(failed_component, log_failure: true)
+        if log_failure
+          Datadog.logger.warn(
+            "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
+            "See previous log messages for details."
+          )
+          Datadog::Core::Telemetry::Logger
+            .error("Detected issue with profiler (#{failed_component} component), stopping profiling")
+        end
 
         if failed_component == :worker
           scheduler.disable_reporting

data/lib/datadog/profiling/scheduler.rb

@@ -65,7 +65,7 @@ module Datadog
       rescue Exception => e # rubocop:disable Lint/RescueException
         Datadog.logger.warn(
           "Profiling::Scheduler thread error. " \
-          "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          "Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
         )
         on_failure_proc&.call
         Datadog::Core::Telemetry::Logger.report(e, description: "Profiling::Scheduler thread error")
@@ -136,7 +136,7 @@ module Datadog
           transport.export(flush)
         rescue => e
           Datadog.logger.warn(
-            "Unable to report profile. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+            "Unable to report profile. Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
           )
           Datadog::Core::Telemetry::Logger.report(e, description: "Unable to report profile")
         end

data/lib/datadog/profiling/tasks/exec.rb

@@ -38,10 +38,10 @@ module Datadog
         def exec_with_error_handling(args)
           Kernel.exec(*args)
         rescue Errno::ENOENT => e
-          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(" ")}')"
+          Kernel.warn "ddprofrb exec failed: #{e.class}: #{e} (command was '#{args.join(" ")}')"
           Kernel.exit 127
         rescue Errno::EACCES, Errno::ENOEXEC => e
-          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(" ")}')"
+          Kernel.warn "ddprofrb exec failed: #{e.class}: #{e} (command was '#{args.join(" ")}')"
           Kernel.exit 126
         end
       end

data/lib/datadog/profiling/tasks/setup.rb

@@ -16,7 +16,7 @@ module Datadog
             setup_at_fork_hooks
           rescue StandardError, ScriptError => e
             Datadog.logger.warn do
-              "Profiler extensions unavailable. Cause: #{e.class.name} #{e.message} " \
+              "Profiler extensions unavailable. Cause: #{e.class}: #{e} " \
               "Location: #{Array(e.backtrace).first}"
             end
             Datadog::Core::Telemetry::Logger.report(e, description: "Profiler extensions unavailable")
@@ -31,7 +31,7 @@ module Datadog
             Profiling.start_if_enabled
           rescue => e
             Datadog.logger.warn do
-              "Error during post-fork hooks. Cause: #{e.class.name} #{e.message} " \
+              "Error during post-fork hooks. Cause: #{e.class}: #{e} " \
               "Location: #{Array(e.backtrace).first}"
             end
             Datadog::Core::Telemetry::Logger.report(e, description: "Error during post-fork hooks")

data/lib/datadog/profiling.rb

@@ -61,8 +61,7 @@ module Datadog
     end
 
     def self.enabled?
-      profiler = Datadog.send(:components).profiler
-      !!profiler&.enabled?
+      !!Datadog.send(:components).profiler
     end
 
     def self.wait_until_running(timeout_seconds: 5)

data/lib/datadog/single_step_instrument.rb

@@ -17,5 +17,5 @@ begin
   require_relative 'auto_instrument'
   Datadog::SingleStepInstrument.const_set(:LOADED, true)
 rescue StandardError, LoadError => e
-  warn "Single step instrumentation failed: #{e.class}:#{e.message}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
+  warn "Single step instrumentation failed: #{e.class}: #{e}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
 end

data/lib/datadog/tracing/buffer.rb

@@ -56,7 +56,7 @@ module Datadog
         @buffer_spans += trace.length
       rescue => e
         Datadog.logger.debug(
-          "Failed to measure queue accept. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+          "Failed to measure queue accept. Cause: #{e.class}: #{e} Source: #{Array(e.backtrace).first}"
         )
       end
 
@@ -66,7 +66,7 @@ module Datadog
         @buffer_spans -= trace.length
       rescue => e
         Datadog.logger.debug(
-          "Failed to measure queue drop. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+          "Failed to measure queue drop. Cause: #{e.class}: #{e} Source: #{Array(e.backtrace).first}"
         )
       end
 
@@ -91,7 +91,7 @@ module Datadog
         @buffer_spans = 0
       rescue => e
         Datadog.logger.debug(
-          "Failed to measure queue. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+          "Failed to measure queue. Cause: #{e.class}: #{e} Source: #{Array(e.backtrace).first}"
         )
       end
     end