datadog 2.31.0 → 2.33.0

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,169 @@
+# 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)
+
+        # Emitted unconditionally so the rare oversized case is observable.
+        @telemetry&.distribution('tracers', 'symbol_database.payload_size', compressed_data.bytesize)
+
+        # 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

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

@@ -430,7 +430,7 @@ module Datadog
                       rescue => e
                         # `File#read` errors have clear and actionable messages, no need to add extra exception info.
                         Datadog.logger.warn(
-                          "Cannot read span sampling rules file `#{rules_file}`: #{e.class}: #{e}." \
+                          "Cannot read span sampling rules file `#{rules_file}`: #{e.class}: #{e.message}." \
                           'No span sampling rules will be applied.'
                         )
                         nil

data/lib/datadog/tracing/contrib/action_pack/action_controller/instrumentation.rb

@@ -43,7 +43,7 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_CONTROLLER)
             rescue => e
-              Datadog.logger.error("#{e.class}: #{e}")
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
@@ -88,7 +88,7 @@ module Datadog
                 span.finish
               end
             rescue => e
-              Datadog.logger.error("#{e.class}: #{e}")
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
@@ -121,7 +121,9 @@ module Datadog
                   result
                 # rubocop:disable Lint/RescueException
                 rescue Exception => e
-                  payload[:exception] = [e.class.name, e.message]
+                  # Rails ActiveSupport::Notifications convention — payload[:exception] is
+                  # an array of [class_name_string, message_string] consumed by subscribers.
+                  payload[:exception] = [e.class.name, e.message] # rubocop:disable CustomCops/ExceptionMessageCop
                   payload[:exception_object] = e
                   raise e
                 ensure

data/lib/datadog/tracing/contrib/action_view/events/render_template.rb

@@ -47,7 +47,7 @@ module Datadog
 
               record_exception(span, payload)
             rescue => e
-              Datadog.logger.debug { "#{e.class}: #{e}" }
+              Datadog.logger.debug { "#{e.class}: #{e.message}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_job/events/discard.rb

@@ -40,7 +40,7 @@ module Datadog
               set_common_tags(span, payload)
               span.set_tag(Ext::TAG_JOB_ERROR, payload[:error])
             rescue => e
-              Datadog.logger.debug { "#{e.class}: #{e}" }
+              Datadog.logger.debug { "#{e.class}: #{e.message}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_job/events/enqueue.rb

@@ -39,7 +39,7 @@ module Datadog
 
               set_common_tags(span, payload)
             rescue => e
-              Datadog.logger.debug { "#{e.class}: #{e}" }
+              Datadog.logger.debug { "#{e.class}: #{e.message}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_job/events/enqueue_at.rb

@@ -39,7 +39,7 @@ module Datadog
 
               set_common_tags(span, payload)
             rescue => e
-              Datadog.logger.debug { "#{e.class}: #{e}" }
+              Datadog.logger.debug { "#{e.class}: #{e.message}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_job/events/enqueue_retry.rb

@@ -41,7 +41,7 @@ module Datadog
               span.set_tag(Ext::TAG_JOB_ERROR, payload[:error])
               span.set_tag(Ext::TAG_JOB_RETRY_WAIT, payload[:wait])
             rescue => e
-              Datadog.logger.debug { "#{e.class}: #{e}" }
+              Datadog.logger.debug { "#{e.class}: #{e.message}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_job/events/perform.rb

@@ -39,7 +39,7 @@ module Datadog
 
               set_common_tags(span, payload)
             rescue => e
-              Datadog.logger.debug { "#{e.class}: #{e}" }
+              Datadog.logger.debug { "#{e.class}: #{e.message}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_job/events/retry_stopped.rb

@@ -40,7 +40,7 @@ module Datadog
               set_common_tags(span, payload)
               span.set_tag(Ext::TAG_JOB_ERROR, payload[:error])
             rescue => e
-              Datadog.logger.debug { "#{e.class}: #{e}" }
+              Datadog.logger.debug { "#{e.class}: #{e.message}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_model_serializers/events/render.rb

@@ -35,7 +35,7 @@ module Datadog
 
               set_common_tags(span, payload)
             rescue => e
-              Datadog.logger.debug { "#{e.class}: #{e}" }
+              Datadog.logger.debug { "#{e.class}: #{e.message}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_model_serializers/events/serialize.rb

@@ -37,7 +37,7 @@ module Datadog
 
               set_common_tags(span, payload)
             rescue => e
-              Datadog.logger.debug { "#{e.class}: #{e}" }
+              Datadog.logger.debug { "#{e.class}: #{e.message}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_record/configuration/resolver.rb

@@ -76,7 +76,7 @@ module Datadog
               #
               Datadog.logger.error(
                 'Failed to resolve ActiveRecord database configuration. ' \
-                "Cause: #{e.class.name} Source: #{Array(e.backtrace).first}"
+                "Cause: #{e.class} Source: #{Array(e.backtrace).first}"
               )
               Core::Telemetry::Logger.report(e, description: 'Failed to resolve ActiveRecord database configuration')
 
@@ -96,7 +96,7 @@ module Datadog
             rescue => e
               Datadog.logger.error(
                 "Failed to resolve key #{matcher.inspect}. " \
-                "Cause: #{e.class.name} Source: #{Array(e.backtrace).first}"
+                "Cause: #{e.class} Source: #{Array(e.backtrace).first}"
               )
               Core::Telemetry::Logger.report(e, description: 'Failed to resolve key')
 

data/lib/datadog/tracing/contrib/active_record/events/instantiation.rb

@@ -49,7 +49,7 @@ module Datadog
               span.set_tag(Ext::TAG_INSTANTIATION_CLASS_NAME, payload.fetch(:class_name))
               span.set_tag(Ext::TAG_INSTANTIATION_RECORD_COUNT, payload.fetch(:record_count))
             rescue => e
-              Datadog.logger.error("#{e.class}: #{e}")
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
           end

data/lib/datadog/tracing/contrib/active_record/events/sql.rb

@@ -69,7 +69,7 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, config[:host]) if config[:host]
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, config[:port]) if config[:port]
             rescue => e
-              Datadog.logger.error("#{e.class}: #{e}")
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
           end

data/lib/datadog/tracing/contrib/active_record/utils.rb

@@ -77,7 +77,7 @@ module Datadog
               # in case.
               Datadog.logger.debug(
                 "connection_id #{connection_id} does not represent a valid object. " \
-                        "Cause: #{e.class}: #{e} Source: #{Array(e.backtrace).first}"
+                        "Cause: #{e.class}: #{e.message} Source: #{Array(e.backtrace).first}"
               )
             end
           else

data/lib/datadog/tracing/contrib/active_support/cache/events/cache.rb

@@ -94,7 +94,7 @@ module Datadog
                   set_cache_key(span, key, mapping[:multi_key])
                 end
               rescue => e
-                Datadog.logger.error("#{e.class}: #{e}")
+                Datadog.logger.error("#{e.class}: #{e.message}")
                 Datadog::Core::Telemetry::Logger.report(e)
               end
 

data/lib/datadog/tracing/contrib/active_support/notifications/subscription.rb

@@ -125,7 +125,7 @@ module Datadog
                 @block&.call(span, name, id, payload)
               rescue => e
                 Datadog.logger.debug(
-                  "ActiveSupport::Notifications handler for '#{name}' failed: #{e.class}: #{e}"
+                  "ActiveSupport::Notifications handler for '#{name}' failed: #{e.class}: #{e.message}"
                 )
               end
             end
@@ -147,7 +147,7 @@ module Datadog
                   callback.call(event, key, *args)
                 rescue => e
                   Datadog.logger.debug(
-                    "ActiveSupport::Notifications '#{key}' callback for '#{event}' failed: #{e.class}: #{e}"
+                    "ActiveSupport::Notifications '#{key}' callback for '#{event}' failed: #{e.class}: #{e.message}"
                   )
                 end
               end

data/lib/datadog/tracing/contrib/aws/instrumentation.rb

@@ -90,7 +90,7 @@ module Datadog
 
             Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
           rescue => e
-            Datadog.logger.error("#{e.class}: #{e}")
+            Datadog.logger.error("#{e.class}: #{e.message}")
             Datadog::Core::Telemetry::Logger.report(e)
           end
           # rubocop:enable Metrics/MethodLength

data/lib/datadog/tracing/contrib/component.rb

@@ -20,7 +20,7 @@ module Datadog
             @registry.each do |name, callback|
               callback.call(config)
             rescue => e
-              Datadog.logger.warn("Error configuring integration #{name}: #{e}")
+              Datadog.logger.warn("Error configuring integration #{name}: #{e.class}: #{e.message}")
             end
           end
 

data/lib/datadog/tracing/contrib/configuration/resolver.rb

@@ -95,14 +95,17 @@ module Datadog
             super(*args)
 
             @cache_limit = cache_limit
-            @cache = {}
+            # Workaround for Ruby VM < 3.2.8, < 3.3.8 and < 3.4.3 (see https://bugs.ruby-lang.org/issues/21170)
+            # We initialize the hash with 10 dummy entries + clear it to force Ruby to use an
+            # "st_table" representation for the Hash, not an "ar_table" (since Ruby will not
+            # shrink a Hash using an "st_table" back to an "ar_table")
+            @cache = Hash[*1..20]
+            @cache.clear
           end
 
           # (see Resolver#resolve)
           def resolve(value)
-            if @cache.key?(value)
-              @cache[value]
-            else
+            @cache.fetch(value) do
               if @cache.size >= @cache_limit
                 @cache.shift # Remove the oldest entry if cache is full
               end

data/lib/datadog/tracing/contrib/dalli/quantize.rb

@@ -16,7 +16,7 @@ module Datadog
             command = Core::Utils.utf8_encode(command, binary: true, placeholder: placeholder)
             Core::Utils.truncate(command, Ext::QUANTIZE_MAX_CMD_LENGTH)
           rescue => e
-            Datadog.logger.debug("Error sanitizing Dalli operation: #{e}")
+            Datadog.logger.debug("Error sanitizing Dalli operation: #{e.class}: #{e.message}")
             placeholder
           end
         end

data/lib/datadog/tracing/contrib/elasticsearch/patcher.rb

@@ -98,7 +98,7 @@ module Datadog
                 Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
               rescue => e
                 # TODO: Refactor the code to streamline the execution without ensure
-                Datadog.logger.error("#{e.class}: #{e}")
+                Datadog.logger.error("#{e.class}: #{e.message}")
                 Datadog::Core::Telemetry::Logger.report(e)
               ensure
                 # the call is still executed

data/lib/datadog/tracing/contrib/excon/middleware.rb

@@ -40,7 +40,7 @@ module Datadog
                 span
               end
             rescue => e
-              Datadog.logger.debug { "#{e.class}: #{e}" }
+              Datadog.logger.debug { "#{e.class}: #{e.message}" }
             end
 
             @stack.request_call(datum)
@@ -180,7 +180,7 @@ module Datadog
               end
             end
           rescue => e
-            Datadog.logger.debug { "#{e.class}: #{e}" }
+            Datadog.logger.debug { "#{e.class}: #{e.message}" }
           end
 
           def propagate!(trace, span, datum)

data/lib/datadog/tracing/contrib/extensions.rb

@@ -227,6 +227,15 @@ module Datadog
               end
             end
 
+            # Returns the subset of built-in integrations that are instrumented,
+            # excluding custom integrations registered through the public contrib API.
+            # This method is only for telemetry reporting.
+            # @!visibility private
+            def instrumented_built_in_integrations
+              instrumented = Set.new(instrumented_integrations.each_value)
+              Contrib::BUILT_IN_INTEGRATIONS.select { |integration| instrumented.include?(integration) }.freeze
+            end
+
             # @!visibility private
             def reset!
               INSTRUMENTED_INTEGRATIONS_LOCK.synchronize do

data/lib/datadog/tracing/contrib/faraday/middleware.rb

@@ -83,7 +83,7 @@ module Datadog
 
             Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
           rescue => e
-            Datadog.logger.error("#{e.class}: #{e}")
+            Datadog.logger.error("#{e.class}: #{e.message}")
             Datadog::Core::Telemetry::Logger.report(e)
           end
           # rubocop:enable Metrics/AbcSize
@@ -98,7 +98,7 @@ module Datadog
               Datadog.configuration.tracing.header_tags.response_tags(env[:response_headers])
             )
           rescue => e
-            Datadog.logger.error("#{e.class}: #{e}")
+            Datadog.logger.error("#{e.class}: #{e.message}")
             Datadog::Core::Telemetry::Logger.report(e)
           end
           # rubocop:enable Metrics/AbcSize