datadog 2.31.0 → 2.32.0

data/lib/datadog/symbol_database/file_hash.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+
+module Datadog
+  module SymbolDatabase
+    # Computes Git-style SHA-1 hashes of Ruby source files for backend commit inference.
+    #
+    # Uses Git's blob hash algorithm: SHA1("blob <size>\0<content>")
+    # Hashes enable the backend to correlate runtime code with Git repository history,
+    # identifying which commit is actually deployed.
+    #
+    # Called by: Extractor (when building MODULE scopes)
+    # Stores result in: Scope's language_specifics[:file_hash]
+    # Returns: 40-character hex string or nil if file unreadable
+    #
+    # @api private
+    module FileHash
+      module_function
+
+      # Compute Git-style SHA-1 hash of a file.
+      # Uses Git's blob hash algorithm: SHA1("blob <size>\0<content>")
+      # Returns nil on any error (file not found, permission denied, etc.)
+      #
+      # @param file_path [String] Path to the file
+      # @param logger [#debug] Logger for error reporting
+      # @return [String, nil] 40-character hex-encoded SHA-1 hash, or nil if error
+      def compute(file_path, logger:)
+        return nil unless file_path
+        return nil unless File.exist?(file_path)
+
+        content = File.read(file_path, mode: 'rb')
+        size = content.bytesize
+        git_blob = "blob #{size}\0#{content}"
+
+        # SHA-1 is required here to match Git's blob hash format for commit inference.
+        # This is not a security vulnerability - we're computing file content hashes
+        # to match against Git objects, not using SHA-1 for authentication/integrity.
+        Digest::SHA1.hexdigest(git_blob)  # nosemgrep: ruby.lang.security.weak-hashes-sha1.weak-hashes-sha1
+      rescue => e
+        logger.debug { "symdb: file hash failed for #{file_path}: #{e.class}: #{e.message}" }
+        nil
+      end
+    end
+  end
+end

data/lib/datadog/symbol_database/logger.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Datadog
+  module SymbolDatabase
+    # Logger facade that adds a config-gated +trace+ method.
+    #
+    # Wraps any logger (customer-provided or default) and delegates
+    # standard methods. The +trace+ method is a sub-debug level that
+    # is a no-op unless DD_TRACE_DEBUG is set, avoiding overhead for
+    # high-frequency log sites (per-module filtering, dedup checks).
+    #
+    # @api private
+    class Logger
+      extend Forwardable
+
+      # @param settings [Configuration::Settings] Tracer settings (reads trace_logging flag)
+      # @param target [::Logger] Underlying logger to delegate to
+      def initialize(settings, target)
+        @settings = settings
+        @target = target
+      end
+
+      attr_reader :settings
+
+      # Only debug and warn are delegated by design — symbol database
+      # extraction logs only at debug (high-volume diagnostics) and warn
+      # (user-actionable problems). Adding info/error would invite
+      # log-level drift; explicit additions can be made if needed.
+      def_delegators :@target, :debug, :warn
+
+      # Log at trace level (sub-debug). No-op unless DD_TRACE_DEBUG is set.
+      # @yield Block that returns the log message string
+      # @return [void]
+      def trace(&block)
+        if settings.symbol_database.internal.trace_logging
+          debug(&block)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/symbol_database/scope.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Datadog
+  module SymbolDatabase
+    # Represents a scope in the hierarchical symbol structure (FILE → MODULE/CLASS → METHOD).
+    #
+    # Scopes form a tree structure representing Ruby code organization. Each scope contains:
+    # - Metadata: name, source file, line range, scope type (MODULE/CLASS/METHOD/etc.)
+    # - Symbols: Variables, constants, parameters defined in this scope
+    # - Nested scopes: Child scopes (e.g., methods within a class)
+    #
+    # Created by: Extractor (during symbol extraction)
+    # Used by: ScopeBatcher (batching), ServiceVersion (wrapping for upload)
+    # Serialized to: JSON via to_h/to_json for upload to agent
+    #
+    # @api private
+    class Scope
+      attr_reader :scope_type, :name, :source_file, :start_line, :end_line,
+        # Ranges of executable lines [{start:, end:}]. Three states:
+        # - nil: not computed (source unreadable, native/C-extension method)
+        # - []: computed but no executable lines found (comments/whitespace only)
+        # - non-empty: computed, contains executable line ranges
+        # nil and [] both serialize as injectible_lines?: false on METHOD
+        # scopes. Key is absent on non-METHOD scopes.
+        :injectible_lines,
+        :language_specifics, :symbols, :scopes
+
+      # Initialize a new Scope
+      # @param scope_type [String] Type of scope (FILE, MODULE, CLASS, METHOD)
+      # @param name [String, nil] Name of the scope (class name, method name, etc.)
+      # @param source_file [String, nil] Path to source file
+      # @param start_line [Integer, nil] Starting line number (UNKNOWN_MIN_LINE for unknown)
+      # @param end_line [Integer, nil] Ending line number (UNKNOWN_MAX_LINE for entire file)
+      # @param injectible_lines [Array<Hash>, nil] Ranges of executable lines [{start:, end:}]
+      # @param language_specifics [Hash, nil] Ruby-specific metadata
+      # @param symbols [Array<Symbol>, nil] Symbols defined in this scope
+      # @param scopes [Array<Scope>, nil] Nested child scopes
+      def initialize(
+        scope_type:,
+        name: nil,
+        source_file: nil,
+        start_line: nil,
+        end_line: nil,
+        injectible_lines: nil,
+        language_specifics: nil,
+        symbols: nil,
+        scopes: nil
+      )
+        @scope_type = scope_type
+        @name = name
+        @source_file = source_file
+        @start_line = start_line
+        @end_line = end_line
+        @injectible_lines = injectible_lines
+        @language_specifics = language_specifics || {}
+        @symbols = symbols || []
+        @scopes = scopes || []
+      end
+
+      # @return [Boolean] true when injectible_lines is non-nil and non-empty
+      def injectible_lines?
+        !injectible_lines.nil? && !injectible_lines.empty?
+      end
+
+      # Convert scope to Hash for JSON serialization.
+      # Removes nil values to reduce payload size.
+      # @return [Hash] Scope as hash with symbol keys
+      def to_h
+        h = {
+          scope_type: scope_type,
+          name: name,
+          source_file: source_file,
+          start_line: start_line,
+          end_line: end_line,
+          language_specifics: language_specifics.empty? ? nil : language_specifics,
+          symbols: symbols.empty? ? nil : symbols.map(&:to_h),
+          scopes: scopes.empty? ? nil : scopes.map(&:to_h),
+        }
+        h.compact!
+        # Injectable lines only on METHOD scopes (per spec — not on CLASS/MODULE/FILE).
+        # Always emit has_injectible_lines (even when false) on METHOD scopes.
+        if scope_type == 'METHOD'
+          h[:has_injectible_lines] = injectible_lines? # steep:ignore ArgumentTypeMismatch
+          h[:injectible_lines] = injectible_lines if injectible_lines && !injectible_lines.empty?
+        end
+        h
+      end
+
+      # Serialize scope to JSON.
+      # @return [String] JSON string representation
+      def to_json(_state = nil)
+        JSON.generate(to_h)
+      end
+    end
+  end
+end

data/lib/datadog/symbol_database/service_version.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Datadog
+  module SymbolDatabase
+    # Top-level container wrapping scopes for upload to the agent.
+    #
+    # ServiceVersion is the root object serialized to JSON for symbol database uploads.
+    # Contains service metadata (name, env, version) and all extracted scopes.
+    # The language field identifies the tracer.
+    #
+    # Created by: Uploader (wraps scopes array before serialization)
+    # Contains: Array of top-level Scope objects (FILE scopes)
+    # Serialized to: JSON via to_json, then GZIP compressed for upload
+    #
+    # @api private
+    class ServiceVersion
+      attr_reader :service, :env, :version, :language, :scopes
+
+      # Initialize a new ServiceVersion
+      # @param service [String] Service name (required, from DD_SERVICE)
+      # @param env [String] Environment (from DD_ENV, defaults to "none")
+      # @param version [String] Version (from DD_VERSION, defaults to "none")
+      # @param scopes [Array<Scope>] Top-level scopes (required)
+      # @raise [ArgumentError] if service empty or scopes not an array
+      def initialize(service:, env:, version:, scopes:)
+        raise ArgumentError, 'service is required' if service.nil? || service.empty?
+        raise ArgumentError, 'scopes must be an array' unless scopes.is_a?(Array)
+
+        @service = service
+        @env = env.to_s.empty? ? 'none' : env.to_s
+        @version = version.to_s.empty? ? 'none' : version.to_s
+        @language = 'ruby'
+        @scopes = scopes
+      end
+
+      # Convert service version to Hash for JSON serialization.
+      # @return [Hash] ServiceVersion as hash with symbol keys
+      def to_h
+        {
+          service: service,
+          env: env,
+          version: version,
+          language: language,
+          scopes: scopes.map(&:to_h),
+        }
+      end
+
+      # Serialize service version to JSON.
+      # @return [String] JSON string representation
+      def to_json(_state = nil)
+        JSON.generate(to_h)
+      end
+    end
+  end
+end

data/lib/datadog/symbol_database/symbol.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Datadog
+  module SymbolDatabase
+    # Represents a symbol (variable, parameter, field, constant) within a scope.
+    #
+    # Symbols are the actual identifiers extracted from Ruby code:
+    # - Instance variables (@var) - FIELD type
+    # - Class variables (@@var) - STATIC_FIELD type
+    # - Constants (CONST) - STATIC_FIELD type
+    # - Method parameters (arg) - ARG type
+    # - Local variables (var) - LOCAL type (not yet implemented)
+    #
+    # Created by: Extractor (during class/method introspection)
+    # Contained in: Scope objects (symbols array)
+    # Serialized to: JSON via to_h/to_json
+    #
+    # @api private
+    class Symbol
+      attr_reader :symbol_type, :name, :line, :type, :language_specifics
+
+      # Initialize a new Symbol
+      # @param symbol_type [String] Type: FIELD, STATIC_FIELD, ARG, LOCAL
+      # @param name [String] Symbol name (variable name, parameter name)
+      # @param line [Integer] Line number (UNKNOWN_MIN_LINE for entire scope, UNKNOWN_MAX_LINE for method-level only)
+      # @param type [String, nil] Type annotation (optional, Ruby is dynamic)
+      # @param language_specifics [Hash, nil] Symbol-specific metadata
+      def initialize(
+        symbol_type:,
+        name:,
+        line:,
+        type: nil,
+        language_specifics: nil
+      )
+        @symbol_type = symbol_type
+        @name = name
+        @line = line
+        @type = type
+        @language_specifics = language_specifics
+      end
+
+      # Convert symbol to Hash for JSON serialization.
+      # Removes nil values to reduce payload size.
+      # @return [Hash] Symbol as hash with symbol keys
+      def to_h
+        h = {
+          symbol_type: symbol_type,
+          name: name,
+          line: line,
+          type: type,
+          language_specifics: language_specifics,
+        }
+        h.compact!
+        h
+      end
+
+      # Serialize symbol to JSON.
+      # @return [String] JSON string representation
+      def to_json(_state = nil)
+        JSON.generate(to_h)
+      end
+    end
+  end
+end

data/lib/datadog/symbol_database/transport/http/endpoint.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/transport/http/api/endpoint'
+
+module Datadog
+  module SymbolDatabase
+    module Transport
+      module HTTP
+        module API
+          # POST endpoint for symbol database uploads. Multipart form-data
+          # is triggered by setting `env.form` on the request (handled in
+          # `Core::Transport::HTTP::Adapters::Net`); the multipart library
+          # sets Content-Type itself.
+          class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
+            attr_reader :encoder
+
+            # @param path [String] URL path for the endpoint
+            # @param encoder [#encode] Encoder for request data
+            def initialize(path, encoder)
+              super(:post, path)
+              @encoder = encoder
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../../core/encoding'
+require_relative '../../core/transport/http'
+require_relative 'http/endpoint'
+require_relative '../transport'
+
+module Datadog
+  module SymbolDatabase
+    module Transport
+      # Namespace for HTTP transport components
+      module HTTP
+        # POST endpoint for the agent's symbol database intake.
+        # Multipart form-data is dispatched via `env.form` from the
+        # `Symbols::Client` subclass.
+        SYMBOLS_ENDPOINT = API::Endpoint.new(
+          '/symdb/v1/input',
+          Datadog::Core::Encoding::JSONEncoder,
+        )
+
+        # Builds a transport for the symbols upload endpoint.
+        # @param agent_settings [Core::Configuration::AgentSettingsResolver::AgentSettings]
+        #   Agent connection settings (host, port, timeout, etc.)
+        # @param logger [Logger] Logger instance
+        # @param headers [Hash, nil] Optional additional headers
+        # @return [Symbols::Transport] Transport for the symbols endpoint
+        def self.symbols(
+          agent_settings:,
+          logger:,
+          headers: nil
+        )
+          Core::Transport::HTTP.build(
+            logger: logger,
+            agent_settings: agent_settings,
+            headers: headers,
+          ) do |transport|
+            transport.api 'symbols', SYMBOLS_ENDPOINT, default: true
+
+            yield(transport) if block_given?
+          end.to_transport(SymbolDatabase::Transport::Symbols::Transport)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/symbol_database/transport.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative '../core/transport/request'
+require_relative '../core/transport/transport'
+require_relative '../core/transport/http/client'
+require_relative '../core/transport/http/env'
+
+module Datadog
+  module SymbolDatabase
+    module Transport
+      # Transport classes for the symbols upload endpoint.
+      # Mirrors the per-purpose split used by DI (`DI::Transport::Input::*`).
+      module Symbols
+        # Request wrapper carrying the multipart form for a symbols upload.
+        class Request < Core::Transport::Request
+          attr_reader :form
+
+          # @param form [Hash] Multipart form data with UploadIO objects
+          def initialize(form)
+            @form = form
+            # Multipart upload — no parcel; the Net adapter reads form data
+            # off the env directly.
+            super(nil)
+          end
+        end
+
+        # HTTP client for symbol database uploads.
+        # Extends Core::Transport::HTTP::Client to set `env.form`, which the
+        # Net adapter (lib/datadog/core/transport/http/adapters/net.rb) detects
+        # and dispatches as multipart/form-data.
+        class Client < Core::Transport::HTTP::Client
+          # @param request [Request] Symbols upload request
+          # @return [Core::Transport::HTTP::Env] Env with form data set
+          def build_env(request)
+            Core::Transport::HTTP::Env.new(request, form: request.form)
+          end
+        end
+
+        # Transport for the symbols upload endpoint.
+        class Transport < Core::Transport::Transport
+          self.http_client_class = Client
+
+          # Send a symbols upload to the agent.
+          # @param form [Hash] Multipart form data with UploadIO objects
+          # @return [Core::Transport::Response] Response from agent
+          def send_symbols(form)
+            request = Request.new(form)
+            client.send_request(:symbols, request)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/symbol_database/uploader.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'zlib'
+require 'stringio'
+require_relative '../core/environment/identity'
+require_relative '../core/vendor/multipart-post/multipart/post/composite_read_io'
+require_relative 'service_version'
+require_relative 'transport/http'
+
+module Datadog
+  module SymbolDatabase
+    # Uploads symbol database payloads to the Datadog agent via HTTP multipart.
+    #
+    # Handles the complete upload process:
+    # 1. Wraps scopes in ServiceVersion (adds service/env/version metadata)
+    # 2. Serializes to JSON
+    # 3. Compresses with GZIP (always, ~40:1 ratio expected)
+    # 4. Builds multipart form: event.json (metadata) + symbols_{pid}.json.gz (data)
+    # 5. POSTs to agent at /symdb/v1/input via Core::Transport::HTTP
+    # No retries — single attempt. Any failure is logged at debug and discarded.
+    #
+    # Uses Core::Transport::HTTP infrastructure (consistent with DI, Profiling, DataStreams).
+    # Headers: DD-API-KEY, Datadog-Container-ID, Datadog-Entity-ID (automatic from transport)
+    #
+    # Called by: ScopeBatcher.perform_upload (when batch ready)
+    # Calls: Transport::HTTP for network, Zlib for compression
+    #
+    # @api private
+    class Uploader
+      MAX_PAYLOAD_SIZE = 50 * 1024 * 1024  # 50MB
+
+      # Initialize uploader.
+      # @param settings [Configuration::Settings] Tracer settings (for service, env, version metadata)
+      # @param agent_settings [Configuration::AgentSettings] Agent connection settings
+      # @param logger [Logger] Logger instance
+      # @param telemetry [Telemetry, nil] Optional telemetry component for error reporting
+      def initialize(settings:, agent_settings:, logger:, telemetry: nil)
+        @settings = settings
+        @agent_settings = agent_settings
+        @logger = logger
+        @telemetry = telemetry
+
+        @transport = Transport::HTTP.symbols(
+          agent_settings: agent_settings,
+          logger: @logger,
+        )
+      end
+
+      # Upload a batch of scopes to the agent.
+      # Wraps in ServiceVersion, serializes to JSON, compresses with GZIP,
+      # builds multipart form, and POSTs to /symdb/v1/input via transport.
+      # No retries — single attempt, matching Python behavior.
+      # @param scopes [Array<Scope>] Scopes to upload
+      # @return [void]
+      def upload_scopes(scopes)
+        return if scopes.empty?
+
+        json_data = build_symbol_payload(scopes)
+        compressed_data = Zlib.gzip(json_data)
+
+        # Symbols for very large applications (>50MB after gzip) are dropped:
+        # the upload is skipped and the customer sees no autocomplete /
+        # symbol probe results for those classes. Java handles the same case
+        # by splitting the payload across multiple requests; we have not
+        # implemented splitting here. Deferred for a post-MVP follow-up.
+        if compressed_data.bytesize > MAX_PAYLOAD_SIZE
+          @logger.debug { "symdb: payload too large: #{compressed_data.bytesize}/#{MAX_PAYLOAD_SIZE} bytes, skipping" }
+          return
+        end
+
+        perform_http_upload(compressed_data, scopes.size)
+      rescue => e
+        @logger.debug { "symdb: upload failed: #{e.class}: #{e.message}" }
+        @telemetry&.report(e, description: 'symdb: upload failed')
+      end
+
+      private
+
+      # Build JSON payload from scopes.
+      # @param scopes [Array<Scope>] Scopes to serialize
+      # @return [String] JSON string
+      def build_symbol_payload(scopes)
+        ServiceVersion.new(
+          service: @settings.service,
+          env: @settings.env,
+          version: @settings.version,
+          scopes: scopes,
+        ).to_json
+      end
+
+      # Perform HTTP POST with multipart form-data via transport layer.
+      # @param compressed_data [String] GZIP compressed JSON payload
+      # @param scope_count [Integer] Number of scopes (for logging)
+      # @return [void]
+      def perform_http_upload(compressed_data, scope_count)
+        form = build_multipart_form(compressed_data)
+        response = @transport.send_symbols(form)
+        handle_response(response, scope_count)
+      end
+
+      # Build multipart form-data with event metadata and compressed symbols.
+      # @param compressed_data [String] GZIP compressed JSON payload
+      # @return [Hash] Form data hash with UploadIO objects
+      def build_multipart_form(compressed_data)
+        event_io = StringIO.new(build_event_metadata)
+        file_io = StringIO.new(compressed_data)
+
+        event_upload = Datadog::Core::Vendor::Multipart::Post::UploadIO.new(
+          event_io,
+          'application/json',
+          'event.json',
+        )
+
+        file_upload = Datadog::Core::Vendor::Multipart::Post::UploadIO.new(
+          file_io,
+          'application/gzip',
+          "symbols_#{Process.pid}.json.gz",
+        )
+
+        {
+          'event' => event_upload,
+          'file' => file_upload,
+        }
+      end
+
+      # Build event.json metadata part.
+      # @return [String] JSON string for event metadata
+      def build_event_metadata
+        JSON.generate(
+          ddsource: 'ruby',
+          service: @settings.service,
+          runtimeId: Datadog::Core::Environment::Identity.id,
+          parentId: nil,  # Fork tracking deferred for MVP
+          type: 'symdb',
+        )
+      end
+
+      # Handle HTTP response and track metrics.
+      # @param response [Core::Transport::Response] HTTP response from agent
+      # @param scope_count [Integer] Number of scopes uploaded
+      # @return [Boolean] true if successful, false otherwise
+      def handle_response(response, scope_count)
+        if response.internal_error?
+          @logger.debug { "symdb: upload failed: #{response.error.class}: #{response.error}" } # steep:ignore NoMethod
+          return false
+        end
+
+        case response.code
+        when 200..299
+          @logger.debug { "symdb: uploaded #{scope_count} scopes successfully" }
+          true
+        when 429
+          @logger.debug { "symdb: upload rejected: rate limited (429)" }
+          false
+        when 500..599
+          @logger.debug { "symdb: upload rejected: server error (#{response.code})" }
+          false
+        else
+          @logger.debug { "symdb: upload rejected: #{response.code}" }
+          false
+        end
+      end
+    end
+  end
+end

data/lib/datadog/symbol_database.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Datadog
+  # Namespace for Datadog symbol database upload.
+  #
+  # @api private
+  module SymbolDatabase
+    # Sentinel value for unknown or unavailable minimum line number.
+    #
+    # Used for:
+    # 1. start_line when exact line cannot be determined (e.g., modules without methods)
+    # 2. Symbol line numbers for FIELD, STATIC_FIELD, ARG symbols to indicate
+    #    the symbol is available throughout the entire enclosing scope
+    #
+    # Backend behavior: line=0 means symbol completes in every line of the scope
+    #
+    # Reference: Symbol Database Backend RFC, section "Edge Cases"
+    # - "We use 0 for FIELD, STATIC_FIELD and ARG. It means that the symbol
+    #   will be completed in every line of the enclosing scope (CLASS or METHOD)."
+    #
+    # @see https://www.postgresql.org/docs/current/datatype-numeric.html
+    UNKNOWN_MIN_LINE = 0
+
+    # Sentinel value for unknown or unavailable maximum line number.
+    #
+    # Used for:
+    # 1. end_line when exact boundaries cannot be determined (e.g., modules, classes
+    #    without methods, fallback when introspection fails)
+    # 2. LOCAL symbol line numbers when exact line is unknown (future feature)
+    #
+    # Value: 2147483647 (PostgreSQL signed INT_MAX, 2^31 - 1)
+    #
+    # Backend behavior:
+    # - For scopes: indicates "entire file" or "unknown end"
+    # - For LOCAL symbols (future): included in method probe completions but excluded
+    #   from line probe completions
+    #
+    # Protocol specification:
+    # - "If the symbols of the scope should be available to all lines in the
+    #   source_file of the scope, use start_line = 0 and end_line = 2147483647
+    #   (maximum signed integer, postgres int max)."
+    # - "For LOCAL symbols, we use 2147483647 (signed int max) to avoid completing
+    #   the symbol for line probes, but keep it in the method for method probe completions."
+    #
+    # Reference: Symbol Database Backend RFC, section "Scope" and "Edge Cases"
+    # @see https://www.postgresql.org/docs/current/datatype-numeric.html
+    UNKNOWN_MAX_LINE = 2147483647
+  end
+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}: #{e} Source: #{Array(e.backtrace).first}"
+          "Failed to measure queue accept. Cause: #{e.class}: #{e.message} 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}: #{e} Source: #{Array(e.backtrace).first}"
+          "Failed to measure queue drop. Cause: #{e.class}: #{e.message} 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}: #{e} Source: #{Array(e.backtrace).first}"
+          "Failed to measure queue. Cause: #{e.class}: #{e.message} Source: #{Array(e.backtrace).first}"
         )
       end
     end