datadog 2.31.0 → 2.33.0

data/lib/datadog/tracing/contrib/grape/endpoint.rb

@@ -77,7 +77,7 @@ module Datadog
 
               Thread.current[KEY_RUN] = true
             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,7 @@ module Datadog
                 span.finish(finish)
               end
             rescue => e
-              Datadog.logger.error("#{e.class}: #{e}")
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
@@ -165,7 +165,7 @@ module Datadog
 
               Thread.current[KEY_RENDER] = true
             rescue => e
-              Datadog.logger.error("#{e.class}: #{e}")
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
@@ -190,7 +190,7 @@ module Datadog
                 span.finish(finish)
               end
             rescue => e
-              Datadog.logger.error("#{e.class}: #{e}")
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
@@ -229,7 +229,7 @@ module Datadog
                 span.finish(finish)
               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/grpc/datadog_interceptor/client.rb

@@ -90,7 +90,7 @@ module Datadog
               end
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
             rescue => e
-              Datadog.logger.debug("GRPC client trace failed: #{e}")
+              Datadog.logger.debug("GRPC client trace failed: #{e.class}: #{e.message}")
             end
 
             def find_deadline(call)
@@ -112,7 +112,7 @@ module Datadog
 
               Core::Utils.extract_host_port(peer_address)
             rescue => e
-              Datadog.logger.debug { "Could not parse host:port from #{call}: #{e}" }
+              Datadog.logger.debug { "Could not parse host:port from #{call}: #{e.class}: #{e.message}" }
               nil
             end
           end

data/lib/datadog/tracing/contrib/grpc/datadog_interceptor/server.rb

@@ -54,7 +54,7 @@ module Datadog
               Tracing.continue_trace!(GRPC.extract(metadata))
             rescue => e
               Datadog.logger.debug(
-                "unable to propagate GRPC metadata to context: #{e}"
+                "unable to propagate GRPC metadata to context: #{e.class}: #{e.message}"
               )
             end
 
@@ -86,7 +86,7 @@ module Datadog
               # Measure service stats
               Contrib::Analytics.set_measured(span)
             rescue => e
-              Datadog.logger.debug("GRPC server trace failed: #{e}")
+              Datadog.logger.debug("GRPC server trace failed: #{e.class}: #{e.message}")
             end
           end
         end

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

@@ -93,7 +93,7 @@ module Datadog
 
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
             rescue => e
-              Datadog.logger.error("error preparing span from http request: #{e}")
+              Datadog.logger.error("error preparing span from http request: #{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
@@ -108,7 +108,7 @@ module Datadog
                 Datadog.configuration.tracing.header_tags.response_tags(response)
               )
             rescue => e
-              Datadog.logger.error("error preparing span from http response: #{e}")
+              Datadog.logger.error("error preparing span from http response: #{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 

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

@@ -41,7 +41,9 @@ module Datadog
                   # Add additional request specific tags to the span.
                   annotate_span_with_request!(span, req, request_options)
                 rescue => e
-                  Datadog.logger.error("error preparing span for httpclient request: #{e}, Source: #{e.backtrace}")
+                  Datadog.logger.error(
+                    "error preparing span for httpclient request: #{e.class}: #{e.message}, Source: #{e.backtrace}"
+                  )
                   Datadog::Core::Telemetry::Logger.report(e)
                 ensure
                   res = super
@@ -107,7 +109,9 @@ module Datadog
                 Datadog.configuration.tracing.header_tags.response_tags(response.header)
               )
             rescue => e
-              Datadog.logger.error("error preparing span from httpclient response: #{e}, Source: #{e.backtrace}")
+              Datadog.logger.error(
+                "error preparing span from httpclient response: #{e.class}: #{e.message}, Source: #{e.backtrace}"
+              )
               Datadog::Core::Telemetry::Logger.report(e)
             end
 

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

@@ -41,7 +41,7 @@ module Datadog
                   # Add additional request specific tags to the span.
                   annotate_span_with_request!(span, req, request_options)
                 rescue => e
-                  logger.error("error preparing span for http.rb request: #{e}, Source: #{e.backtrace}")
+                  logger.error("error preparing span for http.rb request: #{e.class}: #{e.message}, Source: #{e.backtrace}")
                   Datadog::Core::Telemetry::Logger.report(e)
                 ensure
                   res = super(req, options)
@@ -117,7 +117,7 @@ module Datadog
                 Datadog.configuration.tracing.header_tags.response_tags(response.headers)
               )
             rescue => e
-              logger.error("error preparing span from http.rb response: #{e}, Source: #{e.backtrace}")
+              logger.error("error preparing span from http.rb response: #{e.class}: #{e.message}, Source: #{e.backtrace}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 

data/lib/datadog/tracing/contrib/kafka/instrumentation/consumer.rb

@@ -27,7 +27,7 @@ module Datadog
                       auto_instrumentation: true
                     ) { |key| headers[key] }
                   rescue => e
-                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e.message}")
                   end
 
                   yield(message) if block
@@ -49,7 +49,7 @@ module Datadog
                       auto_instrumentation: true
                     )
                   rescue => e
-                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e.message}")
                   end
 
                   yield(batch) if block

data/lib/datadog/tracing/contrib/kafka/instrumentation/producer.rb

@@ -30,7 +30,7 @@ module Datadog
                       end
                     end
                   rescue => e
-                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e.message}")
                   end
                 end
 
@@ -51,7 +51,7 @@ module Datadog
                       end
                     end
                   rescue => e
-                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e.message}")
                   end
                 end
 

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

@@ -49,7 +49,7 @@ module Datadog
                       auto_instrumentation: true
                     ) { |key| headers[key] }
                   rescue => e
-                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e.message}")
                   end
                 end
 

data/lib/datadog/tracing/contrib/mongodb/subscribers.rb

@@ -73,7 +73,7 @@ module Datadog
             # set the resource with the quantized query
             span.resource = serialized_query
           rescue => e
-            Datadog.logger.debug("error when handling MongoDB 'started' event: #{e}")
+            Datadog.logger.debug("error when handling MongoDB 'started' event: #{e.class}: #{e.message}")
           end
           # rubocop:enable Metrics/AbcSize
 
@@ -85,7 +85,7 @@ module Datadog
             # the framework itself, so we set only the error and the message
             span.set_error(event)
           rescue => e
-            Datadog.logger.debug("error when handling MongoDB 'failed' event: #{e}")
+            Datadog.logger.debug("error when handling MongoDB 'failed' event: #{e.class}: #{e.message}")
           ensure
             # whatever happens, the Span must be removed from the local storage and
             # it must be finished to prevent any leak
@@ -101,7 +101,7 @@ module Datadog
             rows = event.reply.fetch('n', nil)
             span.set_tag(Ext::TAG_ROWS, rows) unless rows.nil?
           rescue => e
-            Datadog.logger.debug("error when handling MongoDB 'succeeded' event: #{e}")
+            Datadog.logger.debug("error when handling MongoDB 'succeeded' event: #{e.class}: #{e.message}")
           ensure
             # whatever happens, the Span must be removed from the local storage and
             # it must be finished to prevent any leak

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

@@ -84,7 +84,7 @@ module Datadog
                 span.resource = "#{method} #{quantized_url}"
                 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)
                 # TODO: Refactor the code to streamline the execution without ensure
               ensure

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

@@ -28,7 +28,7 @@ module Datadog
                     span.type = Tracing::Metadata::Ext::SQL::TYPE
                     span.set_tag(Ext::TAG_QUERY_ASYNC, false)
                   rescue => e
-                    Datadog.logger.debug("error preparing span for presto: #{e}")
+                    Datadog.logger.debug("error preparing span for presto: #{e.class}: #{e.message}")
                   end
 
                   super(query)
@@ -46,7 +46,7 @@ module Datadog
                     span.type = Tracing::Metadata::Ext::SQL::TYPE
                     span.set_tag(Ext::TAG_QUERY_ASYNC, !blk.nil?)
                   rescue => e
-                    Datadog.logger.debug("error preparing span for presto: #{e}")
+                    Datadog.logger.debug("error preparing span for presto: #{e.class}: #{e.message}")
                   end
 
                   super(query, &blk)
@@ -65,7 +65,7 @@ module Datadog
                     # ^ not an SQL type span, since there's no SQL query
                     span.set_tag(Ext::TAG_QUERY_ID, query_id)
                   rescue => e
-                    Datadog.logger.debug("error preparing span for presto: #{e}")
+                    Datadog.logger.debug("error preparing span for presto: #{e.class}: #{e.message}")
                   end
 
                   super(query_id)

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

@@ -54,6 +54,12 @@ module Datadog
               o.type :string, nilable: true
             end
 
+            option :inferred_proxy_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_INFERRED_PROXY_ENABLED
+              o.default false
+            end
+
             option :web_service_name, default: Ext::DEFAULT_PEER_WEBSERVER_SERVICE_NAME, type: :string
           end
         end

data/lib/datadog/tracing/contrib/rack/ext.rb

@@ -9,6 +9,7 @@ module Datadog
         module Ext
           ENV_ENABLED = 'DD_TRACE_RACK_ENABLED'
           ENV_DISTRIBUTED_TRACING = 'DD_TRACE_RACK_DISTRIBUTED_TRACING'
+          ENV_INFERRED_PROXY_ENABLED = 'DD_TRACE_INFERRED_PROXY_SERVICES_ENABLED'
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_RACK_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RACK_ANALYTICS_SAMPLE_RATE'
@@ -24,6 +25,32 @@ module Datadog
           TAG_OPERATION_HTTP_SERVER_QUEUE = 'queue'
           WEBSERVER_APP = 'webserver'
           DEFAULT_PEER_WEBSERVER_SERVICE_NAME = 'web-server'
+
+          # @!visibility private
+          HEADER_X_DD_PROXY = 'HTTP_X_DD_PROXY'
+          HEADER_X_DD_PROXY_REQUEST_TIME_MS = 'HTTP_X_DD_PROXY_REQUEST_TIME_MS'
+          HEADER_X_DD_PROXY_PATH = 'HTTP_X_DD_PROXY_PATH'
+          HEADER_X_DD_PROXY_RESOURCE_PATH = 'HTTP_X_DD_PROXY_RESOURCE_PATH'
+          HEADER_X_DD_PROXY_HTTPMETHOD = 'HTTP_X_DD_PROXY_HTTPMETHOD'
+          HEADER_X_DD_PROXY_DOMAIN_NAME = 'HTTP_X_DD_PROXY_DOMAIN_NAME'
+          HEADER_X_DD_PROXY_STAGE = 'HTTP_X_DD_PROXY_STAGE'
+          HEADER_X_DD_PROXY_ACCOUNT_ID = 'HTTP_X_DD_PROXY_ACCOUNT_ID'
+          HEADER_X_DD_PROXY_API_ID = 'HTTP_X_DD_PROXY_API_ID'
+          HEADER_X_DD_PROXY_REGION = 'HTTP_X_DD_PROXY_REGION'
+          HEADER_X_DD_PROXY_USER = 'HTTP_X_DD_PROXY_USER'
+
+          PROXY_AWS_APIGATEWAY = 'aws-apigateway'
+          PROXY_AWS_HTTPAPI = 'aws-httpapi'
+
+          SPAN_AWS_APIGATEWAY = 'aws.apigateway'
+          SPAN_AWS_HTTPAPI = 'aws.httpapi'
+
+          PROXY_SPAN_NAMES = {
+            PROXY_AWS_APIGATEWAY => SPAN_AWS_APIGATEWAY,
+            PROXY_AWS_HTTPAPI => SPAN_AWS_HTTPAPI,
+          }.freeze
+
+          TAG_INFERRED_SPAN = '_dd.inferred_span'
         end
       end
     end

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

@@ -41,7 +41,7 @@ module Datadog
             # context of middleware patching outside a Rails server process (eg. a
             # process that doesn't serve HTTP requests but has Rails environment
             # loaded such as a Resque master process)
-            Datadog.logger.debug("Error patching middleware stack: #{e}")
+            Datadog.logger.debug("Error patching middleware stack: #{e.class}: #{e.message}")
           end
 
           def retain_middleware_name(middleware)

data/lib/datadog/tracing/contrib/rack/request_queue.rb

@@ -39,7 +39,7 @@ module Datadog
           rescue => e
             # in case of an Exception we don't create a
             # `request.queuing` span
-            Datadog.logger.debug("[rack] unable to parse request queue headers: #{e}")
+            Datadog.logger.debug("[rack] unable to parse request queue headers: #{e.class}: #{e.message}")
             nil
           end
         end

data/lib/datadog/tracing/contrib/rack/trace_proxy_middleware.rb

@@ -13,7 +13,11 @@ module Datadog
         module TraceProxyMiddleware
           module_function
 
-          def call(env, configuration)
+          def call(env, configuration, &block)
+            if configuration[:inferred_proxy_enabled] &&
+                (proxy_type = env[Ext::HEADER_X_DD_PROXY]) && !proxy_type.empty?
+              return call_with_inferred_proxy(env, proxy_type, &block)
+            end
             return yield unless configuration[:request_queuing]
 
             # parse the request queue time
@@ -51,6 +55,118 @@ module Datadog
             queue_span&.finish
             request_span&.finish
           end
+
+          # Creates a virtual parent span representing the upstream proxy
+          # that wraps the actual request processing.
+          #
+          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          def call_with_inferred_proxy(env, proxy_type)
+            span_name = Ext::PROXY_SPAN_NAMES[proxy_type]
+            return yield unless span_name
+
+            request_time_ms = env[Ext::HEADER_X_DD_PROXY_REQUEST_TIME_MS].to_f
+            return yield unless request_time_ms.positive?
+
+            path = env[Ext::HEADER_X_DD_PROXY_PATH]
+            stage = env[Ext::HEADER_X_DD_PROXY_STAGE]
+            domain = env[Ext::HEADER_X_DD_PROXY_DOMAIN_NAME]
+            http_method = env[Ext::HEADER_X_DD_PROXY_HTTPMETHOD]
+            resource_path = env[Ext::HEADER_X_DD_PROXY_RESOURCE_PATH]
+
+            # NOTE: resource_path is the parameterized route (e.g. /users/{id}) vs literal path
+            resource = "#{http_method} #{resource_path || path}" if http_method
+
+            inferred_span = Tracing.trace(
+              span_name,
+              service: domain,
+              type: Tracing::Metadata::Ext::AppTypes::TYPE_WEB,
+              start_time: Time.at(request_time_ms / 1_000),
+            )
+            inferred_span.resource = resource if resource
+            inferred_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, proxy_type)
+            inferred_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
+            inferred_span.set_tag('stage', stage) if stage
+            inferred_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, http_method) if http_method
+            inferred_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, "https://#{domain}#{path}") if domain && path
+            inferred_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, resource_path) if resource_path
+            inferred_span.set_metric(Ext::TAG_INFERRED_SPAN, 1)
+
+            set_optional_tags(inferred_span, env: env, proxy_type: proxy_type)
+
+            yield
+          # NOTE: The underlying {Rack::TraceMiddleware} rescues {Exception}
+          #       to tag the request span with error details.
+          #       We must propagate errors to the inferred proxy parent span.
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            inferred_span&.set_error(e)
+            raise
+          ensure
+            if inferred_span
+              propagate_request_span_tags(inferred_span, env: env)
+
+              if (trace = Tracing.active_trace) && resource
+                trace.resource = resource
+              end
+
+              inferred_span.finish
+            end
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+          # Sets cloud provider metadata and constructs the resource ARN.
+          #
+          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          def set_optional_tags(span, env:, proxy_type:)
+            api_id = env[Ext::HEADER_X_DD_PROXY_API_ID]
+            region = env[Ext::HEADER_X_DD_PROXY_REGION]
+
+            # API Gateway v1 sends region as a single-quoted string
+            region = region.delete("'") if region
+
+            span.set_tag('apiid', api_id) if api_id
+            span.set_tag('region', region) if region
+
+            if (account_id = env[Ext::HEADER_X_DD_PROXY_ACCOUNT_ID])
+              span.set_tag('account_id', account_id)
+            end
+
+            if (user = env[Ext::HEADER_X_DD_PROXY_USER])
+              span.set_tag('aws_user', user)
+            end
+
+            if api_id && region
+              # NOTE: Update this when adding non-AWS proxy types.
+              restapi_prefix = (proxy_type == Ext::PROXY_AWS_APIGATEWAY) ? 'restapis' : 'apis'
+              span.set_tag('dd_resource_key', "arn:aws:apigateway:#{region}::/#{restapi_prefix}/#{api_id}")
+            end
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+          # Propagates response-level and security tags from the request span to
+          # the inferred parent.
+          def propagate_request_span_tags(span, env:)
+            rack_span = env[Ext::RACK_ENV_REQUEST_SPAN]
+            return unless rack_span
+
+            if (status_code = rack_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE))
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, status_code)
+              span.status = rack_span.status
+            end
+
+            if (user_agent = rack_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT))
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT, user_agent)
+            end
+
+            # NOTE: Tracing shouldn't know about AppSec tags.
+            if (appsec_enabled = rack_span.get_metric('_dd.appsec.enabled'))
+              span.set_metric('_dd.appsec.enabled', appsec_enabled)
+            end
+
+            # NOTE: Tracing shouldn't know about AppSec tags.
+            if (appsec_json = rack_span.get_tag('_dd.appsec.json'))
+              span.set_tag('_dd.appsec.json', appsec_json)
+            end
+          end
         end
       end
     end

data/lib/datadog/tracing/contrib/rails/log_injection.rb

@@ -18,7 +18,7 @@ module Datadog
             app_config.log_tags << proc { Tracing.log_correlation if Datadog.configuration.tracing.log_injection }
           rescue => e
             Datadog.logger.warn(
-              "Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.class}: #{e}"
+              "Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.class}: #{e.message}"
             )
             false
           end

data/lib/datadog/tracing/contrib/rails/runner.rb

@@ -86,7 +86,7 @@ module Datadog
                 # Reads one more byte than the limit to allow us to check if the source exceeds the limit.
                 source = File.read(file, MAX_TAG_VALUE_SIZE + 1)
               rescue => e
-                Datadog.logger.debug { "Failed to read file '#{file}' for Rails runner: #{e.class}: #{e}" }
+                Datadog.logger.debug { "Failed to read file '#{file}' for Rails runner: #{e.class}: #{e.message}" }
               end
 
               Tracing.trace(

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

@@ -66,7 +66,7 @@ module Datadog
               span.set_tag(Ext::TAG_TASK_ARG_NAMES, arg_names)
               span.set_tag(Ext::TAG_INVOKE_ARGS, quantize_args(args)) unless args.nil?
             rescue => e
-              Datadog.logger.debug { "Error while tracing Rake invoke: #{e.class}: #{e}" }
+              Datadog.logger.debug { "Error while tracing Rake invoke: #{e.class}: #{e.message}" }
             end
 
             def annotate_execute!(span, args)
@@ -75,7 +75,7 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_EXECUTE)
               span.set_tag(Ext::TAG_EXECUTE_ARGS, quantize_args(args.to_hash)) unless args.nil?
             rescue => e
-              Datadog.logger.debug { "Error while tracing Rake execute: #{e.class}: #{e}" }
+              Datadog.logger.debug { "Error while tracing Rake execute: #{e.class}: #{e.message}" }
             end
 
             def quantize_args(args)

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

@@ -34,7 +34,7 @@ module Datadog
             str = Core::Utils.utf8_encode(arg, binary: true, placeholder: PLACEHOLDER)
             Core::Utils.truncate(str, VALUE_MAX_LEN, TOO_LONG_MARK)
           rescue => e
-            Datadog.logger.debug("non formattable Redis arg #{str}: #{e}")
+            Datadog.logger.debug("non formattable Redis arg #{str}: #{e.class}: #{e.message}")
             PLACEHOLDER
           end
 

data/lib/datadog/tracing/contrib/redis/tags.rb

@@ -47,7 +47,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
 

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

@@ -25,7 +25,7 @@ module Datadog
               job['class'].to_s
             end
           rescue => e
-            Datadog.logger.debug { "Error retrieving Sidekiq job class name (jid:#{job["jid"]}): #{e}" }
+            Datadog.logger.debug { "Error retrieving Sidekiq job class name (jid:#{job["jid"]}): #{e.class}: #{e.message}" }
 
             job['class'].to_s
           end

data/lib/datadog/tracing/contrib/stripe/request.rb

@@ -55,7 +55,7 @@ module Datadog
             span.set_tag(Ext::TAG_REQUEST_PATH, event.path)
             span.set_tag(Ext::TAG_REQUEST_NUM_RETRIES, event.num_retries.to_s)
           rescue => e
-            Datadog.logger.debug { "#{e.class}: #{e}" }
+            Datadog.logger.debug { "#{e.class}: #{e.message}" }
           end
 
           def configuration

data/lib/datadog/tracing/contrib.rb

@@ -81,3 +81,11 @@ require_relative 'contrib/sneakers/integration'
 require_relative 'contrib/stripe/integration'
 require_relative 'contrib/sucker_punch/integration'
 require_relative 'contrib/trilogy/integration'
+
+# This list is used to determine if an integration is a built-in integration,
+# and prevent sending telemetry for custom integrations.
+# To do this, we get the list of registered integrations at this point and freeze it.
+# Later, when custom integrations are registered, they will not be included in this list.
+# .uniq to handle aliases, as we can register the same integration multiple times with different names.
+Datadog::Tracing::Contrib::BUILT_IN_INTEGRATIONS =
+  Datadog::Tracing::Contrib::REGISTRY.map { |entry| entry.klass }.uniq.freeze

data/lib/datadog/tracing/diagnostics/environment_logger.rb

@@ -24,7 +24,9 @@ module Datadog
             end
           end
         rescue => e
-          logger.warn("Failed to collect tracing environment information: #{e} Location: #{Array(e.backtrace).first}")
+          logger.warn(
+            "Failed to collect tracing environment information: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
+          )
         end
       end