datadog 2.2.0 → 2.4.0

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

@@ -93,11 +93,16 @@ module Datadog
                   span.resource = "#{method} #{quantized_url}"
                   Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
                 rescue StandardError => e
+                  # TODO: Refactor the code to streamline the execution without ensure
                   Datadog.logger.error(e.message)
+                  Datadog::Core::Telemetry::Logger.report(e)
                 ensure
                   # the call is still executed
                   response = super
-                  span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
+
+                  if response && response.respond_to?(:status)
+                    span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
+                  end
                 end
               end
               response

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

@@ -7,7 +7,21 @@ module Datadog
       module Ext
         # @public_api
         module DB
+          # Name of the database. This is *not* the database hostname.
+          #
+          # For databases which support such a concept, the default schema/database/namespace
+          # as configured in the connection string.
+          #
+          # If the tracer is already tracking changes to the default schema/database throughout the lifetime of
+          # the session (i.e. the client executes USE {NEW_SCHEMA} and now the default schema has changed from what
+          # was set upon connection initialization), then ideally this attribute reflects the “current” value.
+          # If the tracer is not already tracking changes then just leaving it to the default value set upon
+          # initialization is OK.
+          #
+          # This is the equivalent of OTel’s `db.namespace`
+          # @see https://opentelemetry.io/docs/specs/semconv/database/database-spans/#common-attributes
           TAG_INSTANCE = 'db.instance'
+
           TAG_USER = 'db.user'
           TAG_SYSTEM = 'db.system'
           TAG_STATEMENT = 'db.statement'

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

@@ -7,6 +7,7 @@ require_relative '../http'
 require_relative '../analytics'
 require_relative 'ext'
 require_relative '../http_annotation_helper'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -37,6 +38,7 @@ module Datadog
 
           attr_reader :app
 
+          # rubocop:disable Metrics/AbcSize
           def annotate!(span, env, options)
             span.resource = resource_name(env)
             span.service = service_name(env[:url].host, options)
@@ -75,7 +77,11 @@ module Datadog
             )
 
             Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+          rescue StandardError => e
+            Datadog.logger.error(e.message)
+            Datadog::Core::Telemetry::Logger.report(e)
           end
+          # rubocop:enable Metrics/AbcSize
 
           def handle_response(span, env, options)
             span.set_error(["Error #{env[:status]}", env[:body]]) if options[:error_status_codes].include? env[:status]
@@ -85,6 +91,9 @@ module Datadog
             span.set_tags(
               Datadog.configuration.tracing.header_tags.response_tags(env[:response_headers])
             )
+          rescue StandardError => e
+            Datadog.logger.error(e.message)
+            Datadog::Core::Telemetry::Logger.report(e)
           end
 
           def propagate!(trace, span, env)

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../../core'
+require_relative '../../../core/telemetry/logger'
 require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative '../rack/ext'
@@ -41,6 +42,7 @@ module Datadog
 
               # collect endpoint details
               endpoint = payload.fetch(:endpoint)
+              env = payload.fetch(:env)
               api_view = api_view(endpoint.options[:for])
               request_method = endpoint.options.fetch(:method).first
               path = endpoint_expand_path(endpoint)
@@ -61,9 +63,22 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ENDPOINT_RUN)
 
+              if (grape_route = env['grape.routing_args']) && grape_route[:route_info]
+                trace.set_tag(
+                  Tracing::Metadata::Ext::HTTP::TAG_ROUTE,
+                  # here we are removing the format from the path:
+                  # e.g. /path/to/resource(.json) => /path/to/resource
+                  # e.g. /path/to/resource(.:format) => /path/to/resource
+                  grape_route[:route_info].path&.gsub(/\(\.:?\w+\)\z/, '')
+                )
+
+                trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, env['SCRIPT_NAME'])
+              end
+
               Thread.current[KEY_RUN] = true
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def endpoint_run(name, start, finish, id, payload)
@@ -107,6 +122,7 @@ module Datadog
               end
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             # Status code resolution is tied to the exception handling
@@ -150,6 +166,7 @@ module Datadog
               Thread.current[KEY_RENDER] = true
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def endpoint_render(name, start, finish, id, payload)
@@ -174,6 +191,7 @@ module Datadog
               end
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def endpoint_run_filters(name, start, finish, id, payload)
@@ -212,6 +230,7 @@ module Datadog
               end
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             private

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

@@ -21,13 +21,18 @@ module Datadog
           end
 
           def patch
+            # DEV-3.0: We should remove as many patching options as possible, given the alternatives do not
+            # DEV-3.0: provide any benefit to the recommended `with_unified_tracer` patching method.
+            # DEV-3.0: `with_deprecated_tracer` is likely safe to remove.
+            # DEV-3.0: `with_unified_tracer: false` should be removed if possible.
+            # DEV-3.0: `with_unified_tracer: true` should be the default and hopefully not even necessary as an option.
             if configuration[:with_deprecated_tracer]
-              TracingPatcher.patch!(schemas, trace_options)
+              TracingPatcher.patch!(schemas)
             elsif Integration.trace_supported?
               if configuration[:with_unified_tracer]
-                UnifiedTracePatcher.patch!(schemas, trace_options)
+                UnifiedTracePatcher.patch!(schemas)
               else
-                TracePatcher.patch!(schemas, trace_options)
+                TracePatcher.patch!(schemas)
               end
             else
               Datadog.logger.warn(
@@ -35,18 +40,10 @@ module Datadog
                 'or Datadog::Tracing::Contrib::GraphQL::UnifiedTrace.'\
                 'Falling back to GraphQL::Tracing::DataDogTracing.'
               )
-              TracingPatcher.patch!(schemas, trace_options)
+              TracingPatcher.patch!(schemas)
             end
           end
 
-          def trace_options
-            {
-              service: configuration[:service_name],
-              analytics_enabled: Contrib::Analytics.enabled?(configuration[:analytics_enabled]),
-              analytics_sample_rate: configuration[:analytics_sample_rate]
-            }
-          end
-
           def configuration
             Datadog.configuration.tracing[:graphql]
           end

data/lib/datadog/tracing/contrib/graphql/trace_patcher.rb

@@ -8,12 +8,12 @@ module Datadog
         module TracePatcher
           module_function
 
-          def patch!(schemas, options)
+          def patch!(schemas)
             if schemas.empty?
-              ::GraphQL::Schema.trace_with(::GraphQL::Tracing::DataDogTrace, **options)
+              ::GraphQL::Schema.trace_with(::GraphQL::Tracing::DataDogTrace)
             else
               schemas.each do |schema|
-                schema.trace_with(::GraphQL::Tracing::DataDogTrace, **options)
+                schema.trace_with(::GraphQL::Tracing::DataDogTrace)
               end
             end
           end

data/lib/datadog/tracing/contrib/graphql/tracing_patcher.rb

@@ -8,13 +8,13 @@ module Datadog
         module TracingPatcher
           module_function
 
-          def patch!(schemas, options)
+          def patch!(schemas)
             if schemas.empty?
-              ::GraphQL::Schema.tracer(::GraphQL::Tracing::DataDogTracing.new(**options))
+              ::GraphQL::Schema.tracer(::GraphQL::Tracing::DataDogTracing.new)
             else
               schemas.each do |schema|
                 if schema.respond_to? :use
-                  schema.use(::GraphQL::Tracing::DataDogTracing, **options)
+                  schema.use(::GraphQL::Tracing::DataDogTracing)
                 else
                   Datadog.logger.warn("Unable to patch #{schema}: Please migrate to class-based schema.")
                 end

data/lib/datadog/tracing/contrib/graphql/unified_trace.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'graphql/tracing'
+require 'graphql'
 
 module Datadog
   module Tracing
@@ -11,14 +11,7 @@ module Datadog
         # which is required to use features such as API Catalog.
         # DEV-3.0: This tracer should be the default one in the next major version.
         module UnifiedTrace
-          # @param analytics_enabled [Boolean] Deprecated
-          # @param analytics_sample_rate [Float] Deprecated
-          # @param service [String|nil] The service name to be set on the spans
-          def initialize(*args, analytics_enabled: false, analytics_sample_rate: 1.0, service: nil, **kwargs)
-            @analytics_enabled = analytics_enabled
-            @analytics_sample_rate = analytics_sample_rate
-
-            @service_name = service
+          def initialize(*args, **kwargs)
             @has_prepare_span = respond_to?(:prepare_span)
             super
           end
@@ -139,7 +132,18 @@ module Datadog
           private
 
           def trace(callable, trace_key, resource, **kwargs)
-            Tracing.trace("graphql.#{trace_key}", resource: resource, service: @service_name, type: 'graphql') do |span|
+            config = Datadog.configuration.tracing[:graphql]
+
+            Tracing.trace(
+              "graphql.#{trace_key}",
+              type: 'graphql',
+              resource: resource,
+              service: config[:service_name]
+            ) do |span|
+              if Contrib::Analytics.enabled?(config[:analytics_enabled])
+                Contrib::Analytics.set_sample_rate(span, config[:analytics_sample_rate])
+              end
+
               yield(span) if block_given?
 
               prepare_span(trace_key, kwargs, span) if @has_prepare_span

data/lib/datadog/tracing/contrib/graphql/unified_trace_patcher.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+if Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version >= Gem::Version.new('2.0.19')
+  require_relative 'unified_trace'
+end
+
 module Datadog
   module Tracing
     module Contrib
@@ -8,13 +12,15 @@ module Datadog
         module UnifiedTracePatcher
           module_function
 
-          def patch!(schemas, options)
-            require_relative 'unified_trace'
+          # TODO: `GraphQL::Schema.trace_with` and `YOUR_SCHEMA.trace_with` don't mix.
+          # TODO: They create duplicate spans when combined.
+          # TODO: We should measure how frequently users use `YOUR_SCHEMA.trace_with`, and hopefully we can remove it.
+          def patch!(schemas)
             if schemas.empty?
-              ::GraphQL::Schema.trace_with(UnifiedTrace, **options)
+              ::GraphQL::Schema.trace_with(UnifiedTrace)
             else
               schemas.each do |schema|
-                schema.trace_with(UnifiedTrace, **options)
+                schema.trace_with(UnifiedTrace)
               end
             end
           end

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

@@ -6,6 +6,7 @@ require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative '../http_annotation_helper'
 require_relative '../utils/quantization/http'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -30,23 +31,19 @@ module Datadog
               return super(req, body, &block) if Contrib::HTTP.should_skip_tracing?(req)
 
               Tracing.trace(Ext::SPAN_REQUEST, on_error: method(:annotate_span_with_error!)) do |span, trace|
-                begin
-                  span.service = service_name(host, request_options, client_config)
-                  span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
-                  span.resource = req.method
-
-                  if Tracing.enabled? && !Contrib::HTTP.should_skip_distributed_tracing?(client_config)
-                    Contrib::HTTP.inject(trace, req)
-                  end
-
-                  # Add additional request specific tags to the span.
-                  annotate_span_with_request!(span, req, request_options)
-                rescue StandardError => e
-                  Datadog.logger.error("error preparing span for http request: #{e}")
-                ensure
-                  response = super(req, body, &block)
+                span.service = service_name(host, request_options, client_config)
+                span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
+                span.resource = req.method
+
+                if Tracing.enabled? && !Contrib::HTTP.should_skip_distributed_tracing?(client_config)
+                  Contrib::HTTP.inject(trace, req)
                 end
 
+                # Add additional request specific tags to the span.
+                annotate_span_with_request!(span, req, request_options)
+
+                response = super(req, body, &block)
+
                 # Add additional response specific tags to the span.
                 annotate_span_with_response!(span, response, request_options)
 
@@ -91,6 +88,9 @@ module Datadog
               )
 
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+            rescue StandardError => e
+              Datadog.logger.error("error preparing span from http request: #{e}")
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def annotate_span_with_response!(span, response, request_options)
@@ -103,6 +103,9 @@ module Datadog
               span.set_tags(
                 Datadog.configuration.tracing.header_tags.response_tags(response)
               )
+            rescue StandardError => e
+              Datadog.logger.error("error preparing span from http response: #{e}")
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def annotate_span_with_error!(span, error)

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

@@ -4,6 +4,7 @@ require_relative '../../metadata/ext'
 require_relative '../http'
 require_relative '../analytics'
 require_relative '../http_annotation_helper'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -36,7 +37,8 @@ module Datadog
                   # Add additional request specific tags to the span.
                   annotate_span_with_request!(span, req, request_options)
                 rescue StandardError => e
-                  logger.error("error preparing span for httpclient request: #{e}, Source: #{e.backtrace}")
+                  Datadog.logger.error("error preparing span for httpclient request: #{e}, Source: #{e.backtrace}")
+                  Datadog::Core::Telemetry::Logger.report(e)
                 ensure
                   res = super
                 end
@@ -100,6 +102,9 @@ module Datadog
               span.set_tags(
                 Datadog.configuration.tracing.header_tags.response_tags(response.header)
               )
+            rescue StandardError => e
+              Datadog.logger.error("error preparing span from httpclient response: #{e}, Source: #{e.backtrace}")
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def annotate_span_with_error!(span, error)
@@ -114,10 +119,6 @@ module Datadog
               Contrib::Analytics.enabled?(request_options[:analytics_enabled])
             end
 
-            def logger
-              Datadog.logger
-            end
-
             def should_skip_distributed_tracing?(client_config)
               return !client_config[:distributed_tracing] if client_config && client_config.key?(:distributed_tracing)
 

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

@@ -13,27 +13,14 @@ module Datadog
         module Patcher
           include Contrib::Patcher
 
-          PATCH_ONLY_ONCE = Core::Utils::OnlyOnce.new
-
           module_function
 
-          def patched?
-            PATCH_ONLY_ONCE.ran?
-          end
-
           def target_version
             Integration.version
           end
 
-          # patch applies our patch
           def patch
-            PATCH_ONLY_ONCE.run do
-              begin
-                ::HTTPClient.include(Instrumentation)
-              rescue StandardError => e
-                Datadog.logger.error("Unable to apply httpclient integration: #{e}")
-              end
-            end
+            ::HTTPClient.include(Instrumentation)
           end
         end
       end

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

@@ -4,6 +4,7 @@ require_relative '../../metadata/ext'
 require_relative '../http'
 require_relative '../analytics'
 require_relative '../http_annotation_helper'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -35,6 +36,7 @@ module Datadog
                   annotate_span_with_request!(span, req, request_options)
                 rescue StandardError => e
                   logger.error("error preparing span for http.rb request: #{e}, Source: #{e.backtrace}")
+                  Datadog::Core::Telemetry::Logger.report(e)
                 ensure
                   res = super(req, options)
                 end
@@ -108,6 +110,9 @@ module Datadog
               span.set_tags(
                 Datadog.configuration.tracing.header_tags.response_tags(response.headers)
               )
+            rescue StandardError => e
+              logger.error("error preparing span from http.rb response: #{e}, Source: #{e.backtrace}")
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def annotate_span_with_error!(span, error)

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

@@ -13,27 +13,14 @@ module Datadog
         module Patcher
           include Contrib::Patcher
 
-          PATCH_ONLY_ONCE = Core::Utils::OnlyOnce.new
-
           module_function
 
-          def patched?
-            PATCH_ONLY_ONCE.ran?
-          end
-
           def target_version
             Integration.version
           end
 
-          # patch applies our patch
           def patch
-            PATCH_ONLY_ONCE.run do
-              begin
-                ::HTTP::Client.include(Instrumentation)
-              rescue StandardError => e
-                Datadog.logger.error("Unable to apply httprb integration: #{e}")
-              end
-            end
+            ::HTTP::Client.include(Instrumentation)
           end
         end
       end

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

@@ -20,6 +20,21 @@ module Datadog
 
           # patch applies our patch
           def patch
+            # ActiveSupport::TaggedLogging is the default Rails logger since Rails 5
+            if defined?(::ActiveSupport::TaggedLogging::Formatter) &&
+                ::Lograge::LogSubscribers::ActionController
+                    .logger&.formatter.is_a?(::ActiveSupport::TaggedLogging::Formatter)
+              Datadog.logger.warn(
+                'Lograge and ActiveSupport::TaggedLogging (the default Rails log formatter) are not compatible: ' \
+                  'Lograge does not account for Rails log tags, creating polluted logs and breaking log formatting. ' \
+                  'Traces and Logs correlation may not work. ' \
+                  'Either: 1. Disable tagged logging in your Rails configuration ' \
+                  '`config.logger = ActiveSupport::Logger.new(STDOUT); ' \
+                  'config.active_job.logger = ActiveSupport::Logger.new(STDOUT)` ' \
+                  'or 2. Use the `semantic_logger` gem instead of `lograge`.'
+              )
+            end
+
             ::Lograge::LogSubscribers::Base.include(Instrumentation)
           end
         end

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

@@ -70,6 +70,8 @@ module Datadog
 
             # set the resource with the quantized query
             span.resource = serialized_query
+          rescue StandardError => e
+            Datadog.logger.debug("error when handling MongoDB 'started' event: #{e}")
           end
           # rubocop:enable Metrics/AbcSize
 

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

@@ -48,6 +48,11 @@ module Datadog
               o.default Contrib::Propagation::SqlComment::Ext::DISABLED
             end
 
+            option :append_comment do |o|
+              o.type :bool
+              o.default false
+            end
+
             option :peer_service do |o|
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE

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

@@ -50,21 +50,14 @@ module Datadog
                 # Set analytics sample rate
                 Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
+                span.set_tag(Contrib::Ext::DB::TAG_INSTANCE, query_options[:database])
                 span.set_tag(Ext::TAG_DB_NAME, query_options[:database])
                 span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, query_options[:host])
                 span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, query_options[:port])
 
                 Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
 
-                propagation_mode = Contrib::Propagation::SqlComment::Mode.new(comment_propagation)
-
-                Contrib::Propagation::SqlComment.annotate!(span, propagation_mode)
-                sql = Contrib::Propagation::SqlComment.prepend_comment(
-                  sql,
-                  span,
-                  trace_op,
-                  propagation_mode
-                )
+                sql = inject_propagation(span, sql, trace_op)
 
                 super(sql, options)
               end
@@ -72,6 +65,21 @@ module Datadog
 
             private
 
+            def inject_propagation(span, sql, trace_op)
+              propagation_mode = Contrib::Propagation::SqlComment::Mode.new(
+                datadog_configuration[:comment_propagation],
+                datadog_configuration[:append_comment]
+              )
+
+              Contrib::Propagation::SqlComment.annotate!(span, propagation_mode)
+              Contrib::Propagation::SqlComment.prepend_comment(
+                sql,
+                span,
+                trace_op,
+                propagation_mode
+              )
+            end
+
             def datadog_configuration
               Datadog.configuration.tracing[:mysql2]
             end
@@ -83,10 +91,6 @@ module Datadog
             def analytics_sample_rate
               datadog_configuration[:analytics_sample_rate]
             end
-
-            def comment_propagation
-              datadog_configuration[:comment_propagation]
-            end
           end
         end
       end

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

@@ -6,6 +6,7 @@ require_relative 'ext'
 require_relative '../ext'
 require_relative '../integration'
 require_relative '../patcher'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -81,6 +82,8 @@ module Datadog
                   Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
                 rescue StandardError => e
                   Datadog.logger.error(e.message)
+                  Datadog::Core::Telemetry::Logger.report(e)
+                  # TODO: Refactor the code to streamline the execution without ensure
                 ensure
                   begin
                     response = super
@@ -90,12 +93,16 @@ module Datadog
                     raise
                   end
                   # Set post-response tags
-                  span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
-                  if response.headers['content-length']
-                    span.set_tag(
-                      OpenSearch::Ext::TAG_RESPONSE_CONTENT_LENGTH,
-                      response.headers['content-length'].to_i
-                    )
+                  if response
+                    if response.respond_to?(:status)
+                      span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
+                    end
+                    if response.respond_to?(:headers) && (response.headers || {})['content-length']
+                      span.set_tag(
+                        OpenSearch::Ext::TAG_RESPONSE_CONTENT_LENGTH,
+                        response.headers['content-length'].to_i
+                      )
+                    end
                   end
                 end
               end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../core/utils/only_once'
+require_relative '../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -49,8 +50,8 @@ module Datadog
           # Processes patching errors. This default implementation logs the error and reports relevant metrics.
           # @param e [Exception]
           def on_patch_error(e)
-            # Log the error
             Datadog.logger.error("Failed to apply #{patch_name} patch. Cause: #{e} Location: #{Array(e.backtrace).first}")
+            Datadog::Core::Telemetry::Logger.report(e, description: "Failed to apply #{patch_name} patch")
 
             @patch_error_result = {
               type: e.class.name,

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

@@ -52,6 +52,11 @@ module Datadog
               o.default Contrib::Propagation::SqlComment::Ext::DISABLED
             end
 
+            option :append_comment do |o|
+              o.type :bool
+              o.default false
+            end
+
             option :peer_service do |o|
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE