datadog 2.2.0 → 2.3.0

data/lib/datadog/profiling/ext/dir_monkey_patches.rb

@@ -27,7 +27,7 @@ module Datadog
         end
       end
 
-      if RUBY_VERSION.start_with?('2.')
+      if RUBY_VERSION.start_with?("2.")
         # Monkey patches for Dir.singleton_class (Ruby 2 version). See DirMonkeyPatches above for more details.
         module DirClassMonkeyPatches
           def [](*args, &block)
@@ -260,7 +260,7 @@ module Datadog
         end
       end
 
-      if RUBY_VERSION.start_with?('2.')
+      if RUBY_VERSION.start_with?("2.")
         # Monkey patches for Dir (Ruby 2 version). See DirMonkeyPatches above for more details.
         module DirInstanceMonkeyPatches
           # See note on methods that yield above.
@@ -286,7 +286,7 @@ module Datadog
             end
           end
 
-          unless RUBY_VERSION.start_with?('2.5.') # This is Ruby 2.6+
+          unless RUBY_VERSION.start_with?("2.5.") # This is Ruby 2.6+
             # See note on methods that yield above.
             def each_child(*args, &block)
               if block

data/lib/datadog/profiling/ext.rb

@@ -3,31 +3,31 @@
 module Datadog
   module Profiling
     module Ext
-      ENV_ENABLED = 'DD_PROFILING_ENABLED'
-      ENV_UPLOAD_TIMEOUT = 'DD_PROFILING_UPLOAD_TIMEOUT'
-      ENV_MAX_FRAMES = 'DD_PROFILING_MAX_FRAMES'
-      ENV_AGENTLESS = 'DD_PROFILING_AGENTLESS'
-      ENV_ENDPOINT_COLLECTION_ENABLED = 'DD_PROFILING_ENDPOINT_COLLECTION_ENABLED'
+      ENV_ENABLED = "DD_PROFILING_ENABLED"
+      ENV_UPLOAD_TIMEOUT = "DD_PROFILING_UPLOAD_TIMEOUT"
+      ENV_MAX_FRAMES = "DD_PROFILING_MAX_FRAMES"
+      ENV_AGENTLESS = "DD_PROFILING_AGENTLESS"
+      ENV_ENDPOINT_COLLECTION_ENABLED = "DD_PROFILING_ENDPOINT_COLLECTION_ENABLED"
 
       module Transport
         module HTTP
-          FORM_FIELD_TAG_ENV = 'env'
-          FORM_FIELD_TAG_HOST = 'host'
-          FORM_FIELD_TAG_LANGUAGE = 'language'
-          FORM_FIELD_TAG_PID = 'process_id'
-          FORM_FIELD_TAG_PROFILER_VERSION = 'profiler_version'
-          FORM_FIELD_TAG_RUNTIME = 'runtime'
-          FORM_FIELD_TAG_RUNTIME_ENGINE = 'runtime_engine'
-          FORM_FIELD_TAG_RUNTIME_ID = 'runtime-id'
-          FORM_FIELD_TAG_RUNTIME_PLATFORM = 'runtime_platform'
-          FORM_FIELD_TAG_RUNTIME_VERSION = 'runtime_version'
-          FORM_FIELD_TAG_SERVICE = 'service'
-          FORM_FIELD_TAG_VERSION = 'version'
-          TAG_GIT_REPOSITORY_URL = 'git.repository_url'
-          TAG_GIT_COMMIT_SHA = 'git.commit.sha'
+          FORM_FIELD_TAG_ENV = "env"
+          FORM_FIELD_TAG_HOST = "host"
+          FORM_FIELD_TAG_LANGUAGE = "language"
+          FORM_FIELD_TAG_PID = "process_id"
+          FORM_FIELD_TAG_PROFILER_VERSION = "profiler_version"
+          FORM_FIELD_TAG_RUNTIME = "runtime"
+          FORM_FIELD_TAG_RUNTIME_ENGINE = "runtime_engine"
+          FORM_FIELD_TAG_RUNTIME_ID = "runtime-id"
+          FORM_FIELD_TAG_RUNTIME_PLATFORM = "runtime_platform"
+          FORM_FIELD_TAG_RUNTIME_VERSION = "runtime_version"
+          FORM_FIELD_TAG_SERVICE = "service"
+          FORM_FIELD_TAG_VERSION = "version"
+          TAG_GIT_REPOSITORY_URL = "git.repository_url"
+          TAG_GIT_COMMIT_SHA = "git.commit.sha"
 
-          PPROF_DEFAULT_FILENAME = 'rubyprofile.pprof'
-          CODE_PROVENANCE_FILENAME = 'code-provenance.json'
+          PPROF_DEFAULT_FILENAME = "rubyprofile.pprof"
+          CODE_PROVENANCE_FILENAME = "code-provenance.json"
         end
       end
     end

data/lib/datadog/profiling/flush.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
 module Datadog
   module Profiling

data/lib/datadog/profiling/http_transport.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../core/transport/ext'
+require_relative "../core/transport/ext"
 
 module Datadog
   module Profiling
@@ -53,7 +53,7 @@ module Datadog
 
         if status == :ok
           if (200..299).cover?(result)
-            Datadog.logger.debug('Successfully reported profiling data')
+            Datadog.logger.debug("Successfully reported profiling data")
             true
           else
             Datadog.logger.error(
@@ -73,7 +73,7 @@ module Datadog
       def base_url_from(agent_settings)
         case agent_settings.adapter
         when Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-          "#{agent_settings.ssl ? 'https' : 'http'}://#{agent_settings.hostname}:#{agent_settings.port}/"
+          "#{agent_settings.ssl ? "https" : "http"}://#{agent_settings.hostname}:#{agent_settings.port}/"
         when Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER
           "unix://#{agent_settings.uds_path}"
         else
@@ -82,12 +82,14 @@ module Datadog
       end
 
       def validate_agent_settings(agent_settings)
-        supported_adapters = [Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER,
-                              Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER]
+        supported_adapters = [
+          Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER,
+          Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
+        ]
         unless supported_adapters.include?(agent_settings.adapter)
           raise ArgumentError,
             "Unsupported transport configuration for profiling: Adapter #{agent_settings.adapter} " \
-                        ' is not supported'
+                        " is not supported"
         end
       end
 

data/lib/datadog/profiling/load_native_extension.rb

@@ -15,26 +15,26 @@ begin
   require "datadog_profiling_loader.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
 rescue LoadError => e
   raise LoadError,
-    'Failed to load the profiling loader extension. To fix this, please remove and then reinstall datadog ' \
+    "Failed to load the profiling loader extension. To fix this, please remove and then reinstall datadog " \
     "(Details: #{e.message})"
 end
 
 extension_name = "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
-file_name = "#{extension_name}.#{RbConfig::CONFIG['DLEXT']}"
+file_name = "#{extension_name}.#{RbConfig::CONFIG["DLEXT"]}"
 full_file_path = "#{__dir__}/../../#{file_name}"
 
 unless File.exist?(full_file_path)
-  extension_dir = Gem.loaded_specs['datadog'].extension_dir
+  extension_dir = Gem.loaded_specs["datadog"].extension_dir
   candidate_path = "#{extension_dir}/#{file_name}"
   if File.exist?(candidate_path)
     full_file_path = candidate_path
-  else # rubocop:disable Style/EmptyElse
+  else
     # We found none of the files. This is unexpected. Let's go ahead anyway, the error is going to be reported further
     # down anyway.
   end
 end
 
-init_function_name = "Init_#{extension_name.split('.').first}"
+init_function_name = "Init_#{extension_name.split(".").first}"
 
 status, result = Datadog::Profiling::Loader._native_load(full_file_path, init_function_name)
 

data/lib/datadog/profiling/preload.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../../datadog'
+require_relative "../../datadog"
 
 Datadog::Profiling.start_if_enabled

data/lib/datadog/profiling/profiler.rb

@@ -8,34 +8,30 @@ module Datadog
 
       private
 
-      attr_reader :worker, :scheduler, :optional_crashtracker
+      attr_reader :worker, :scheduler
 
       public
 
-      def initialize(worker:, scheduler:, optional_crashtracker:)
+      def initialize(worker:, scheduler:)
         @worker = worker
         @scheduler = scheduler
-        @optional_crashtracker = optional_crashtracker
       end
 
       def start
         after_fork! do
-          optional_crashtracker.reset_after_fork if optional_crashtracker
           worker.reset_after_fork
           scheduler.reset_after_fork
         end
 
-        optional_crashtracker.start if optional_crashtracker
         worker.start(on_failure_proc: proc { component_failed(:worker) })
         scheduler.start(on_failure_proc: proc { component_failed(:scheduler) })
       end
 
       def shutdown!
-        Datadog.logger.debug('Shutting down profiler')
+        Datadog.logger.debug("Shutting down profiler")
 
         stop_worker
         stop_scheduler
-        optional_crashtracker.stop if optional_crashtracker
       end
 
       private
@@ -52,13 +48,14 @@ module Datadog
       def component_failed(failed_component)
         Datadog.logger.warn(
           "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
-          'See previous log messages for details.'
+          "See previous log messages for details."
         )
 
         # We explicitly not stop the crash tracker in this situation, under the assumption that, if a component failed,
         # we're operating in a degraded state and crash tracking may still be helpful.
 
         if failed_component == :worker
+          scheduler.mark_profiler_failed
           stop_scheduler
         elsif failed_component == :scheduler
           stop_worker

data/lib/datadog/profiling/scheduler.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative '../core/utils/time'
+require_relative "../core/utils/time"
 
-require_relative '../core/worker'
-require_relative '../core/workers/polling'
+require_relative "../core/worker"
+require_relative "../core/workers/polling"
 
 module Datadog
   module Profiling
@@ -22,7 +22,8 @@ module Datadog
 
       attr_reader \
         :exporter,
-        :transport
+        :transport,
+        :profiler_failed
 
       public
 
@@ -34,6 +35,7 @@ module Datadog
       )
         @exporter = exporter
         @transport = transport
+        @profiler_failed = false
 
         # Workers::Async::Thread settings
         self.fork_policy = fork_policy
@@ -50,25 +52,23 @@ module Datadog
       end
 
       def perform(on_failure_proc)
-        begin
-          # A profiling flush may be called while the VM is shutting down, to report the last profile. When we do so,
-          # we impose a strict timeout. This means this last profile may or may not be sent, depending on if the flush can
-          # successfully finish in the strict timeout.
-          # This can be somewhat confusing (why did it not get reported?), so let's at least log what happened.
-          interrupted = true
-
-          flush_and_wait
-          interrupted = false
-        rescue Exception => e # rubocop:disable Lint/RescueException
-          Datadog.logger.warn(
-            'Profiling::Scheduler thread error. ' \
-            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
-          )
-          on_failure_proc&.call
-          raise
-        ensure
-          Datadog.logger.debug('#flush was interrupted or failed before it could complete') if interrupted
-        end
+        # A profiling flush may be called while the VM is shutting down, to report the last profile. When we do so,
+        # we impose a strict timeout. This means this last profile may or may not be sent, depending on if the flush can
+        # successfully finish in the strict timeout.
+        # This can be somewhat confusing (why did it not get reported?), so let's at least log what happened.
+        interrupted = true
+
+        flush_and_wait
+        interrupted = false
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        Datadog.logger.warn(
+          "Profiling::Scheduler thread error. " \
+          "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+        )
+        on_failure_proc&.call
+        raise
+      ensure
+        Datadog.logger.debug("#flush was interrupted or failed before it could complete") if interrupted
       end
 
       # Configure Workers::IntervalLoop to not report immediately when scheduler starts
@@ -80,8 +80,14 @@ module Datadog
         true
       end
 
+      # This is called by the Profiler class whenever an issue happened in the profiler. This makes sure that even
+      # if there is data to be flushed, we don't try to flush it.
+      def mark_profiler_failed
+        @profiler_failed = true
+      end
+
       def work_pending?
-        exporter.can_flush?
+        !profiler_failed && exporter.can_flush?
       end
 
       def reset_after_fork
@@ -124,7 +130,7 @@ module Datadog
 
         begin
           transport.export(flush)
-        rescue StandardError => e
+        rescue => e
           Datadog.logger.error(
             "Unable to report profile. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
           )

data/lib/datadog/profiling/tag_builder.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../core/utils'
-require_relative '../core/environment/git'
+require_relative "../core/utils"
+require_relative "../core/environment/git"
 
 module Datadog
   module Profiling

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

@@ -18,16 +18,16 @@ module Datadog
 
         def rubyopts
           [
-            '-rdatadog/profiling/preload'
+            "-rdatadog/profiling/preload"
           ]
         end
 
         private
 
         def set_rubyopt!
-          existing_rubyopt = ENV['RUBYOPT']
+          existing_rubyopt = ENV["RUBYOPT"]
 
-          ENV['RUBYOPT'] = existing_rubyopt ? "#{existing_rubyopt} #{rubyopts.join(' ')}" : rubyopts.join(' ')
+          ENV["RUBYOPT"] = existing_rubyopt ? "#{existing_rubyopt} #{rubyopts.join(" ")}" : rubyopts.join(" ")
         end
 
         # If there's an error here, rather than throwing a cryptic stack trace, let's instead have clearer messages, and
@@ -38,10 +38,10 @@ module Datadog
         def exec_with_error_handling(args)
           Kernel.exec(*args)
         rescue Errno::ENOENT => e
-          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(' ')}')"
+          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(" ")}')"
           Kernel.exit 127
         rescue Errno::EACCES, Errno::ENOEXEC => e
-          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(' ')}')"
+          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(" ")}')"
           Kernel.exit 126
         end
       end

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

@@ -1,56 +1,37 @@
 # frozen_string_literal: true
 
-require_relative '../../core/utils/only_once'
-require_relative '../ext/forking'
+require_relative "../../core/utils/only_once"
+require_relative "../../core/utils/at_fork_monkey_patch"
 
 module Datadog
   module Profiling
     module Tasks
-      # Takes care of loading our extensions/monkey patches to handle fork() and validating if CPU-time profiling is usable
+      # Takes care of restarting the profiler when the process forks
       class Setup
         ACTIVATE_EXTENSIONS_ONLY_ONCE = Core::Utils::OnlyOnce.new
 
         def run
           ACTIVATE_EXTENSIONS_ONLY_ONCE.run do
-            begin
-              activate_forking_extensions
-              setup_at_fork_hooks
-            rescue StandardError, ScriptError => e
-              Datadog.logger.warn do
-                "Profiler extensions unavailable. Cause: #{e.class.name} #{e.message} " \
-                "Location: #{Array(e.backtrace).first}"
-              end
+            Datadog::Core::Utils::AtForkMonkeyPatch.apply!
+            setup_at_fork_hooks
+          rescue StandardError, ScriptError => e
+            Datadog.logger.warn do
+              "Profiler extensions unavailable. Cause: #{e.class.name} #{e.message} " \
+              "Location: #{Array(e.backtrace).first}"
             end
           end
         end
 
         private
 
-        def activate_forking_extensions
-          if Ext::Forking.supported?
-            Ext::Forking.apply!
-          elsif Datadog.configuration.profiling.enabled
-            Datadog.logger.debug('Profiler forking extensions skipped; forking not supported.')
-          end
-        rescue StandardError, ScriptError => e
-          Datadog.logger.warn do
-            "Profiler forking extensions unavailable. Cause: #{e.class.name} #{e.message} " \
-            "Location: #{Array(e.backtrace).first}"
-          end
-        end
-
         def setup_at_fork_hooks
-          if Process.respond_to?(:at_fork)
-            Process.at_fork(:child) do
-              begin
-                # Restart profiler, if enabled
-                Profiling.start_if_enabled
-              rescue StandardError => e
-                Datadog.logger.warn do
-                  "Error during post-fork hooks. Cause: #{e.class.name} #{e.message} " \
-                  "Location: #{Array(e.backtrace).first}"
-                end
-              end
+          Datadog::Core::Utils::AtForkMonkeyPatch.at_fork(:child) do
+            # Restart profiler, if enabled
+            Profiling.start_if_enabled
+          rescue => e
+            Datadog.logger.warn do
+              "Error during post-fork hooks. Cause: #{e.class.name} #{e.message} " \
+              "Location: #{Array(e.backtrace).first}"
             end
           end
         end

data/lib/datadog/profiling.rb

@@ -30,7 +30,7 @@ module Datadog
       profiler = Datadog.send(:components).profiler
       # ...but we still try to start it BECAUSE if the process forks, the profiler will exist but may
       # not yet have been started in the fork
-      profiler.start if profiler
+      profiler&.start
       !!profiler
     end
 
@@ -47,6 +47,7 @@ module Datadog
     # (This is similar to some OS-based time representations.)
     #
     # Note 2: All fibers in the same thread will share the same counter values.
+    # Note 3: This counter is not accurate when using the M:N scheduler.
     #
     # Only available when the profiler is running, and allocation-related features are not disabled via configuration.
     #
@@ -62,7 +63,7 @@ module Datadog
     def self.enabled?
       profiler = Datadog.send(:components).profiler
       # Use .send(...) to avoid exposing the attr_reader as an API to the outside
-      !!(profiler.send(:scheduler).running? if profiler)
+      !!profiler&.send(:scheduler)&.running?
     end
 
     def self.wait_until_running(timeout_seconds: 5)
@@ -97,7 +98,7 @@ module Datadog
 
         contents = file_api.read(skipped_reason_file).strip
         contents unless contents.empty?
-      rescue StandardError
+      rescue
         # Do nothing
       end
     end
@@ -135,7 +136,6 @@ module Datadog
     private_class_method def self.load_profiling
       return false unless supported?
 
-      require_relative 'profiling/ext/forking'
       require_relative 'profiling/ext/dir_monkey_patches'
       require_relative 'profiling/collectors/info'
       require_relative 'profiling/collectors/code_provenance'
@@ -144,7 +144,6 @@ module Datadog
       require_relative 'profiling/collectors/idle_sampling_helper'
       require_relative 'profiling/collectors/stack'
       require_relative 'profiling/collectors/thread_context'
-      require_relative 'profiling/crashtracker'
       require_relative 'profiling/stack_recorder'
       require_relative 'profiling/exporter'
       require_relative 'profiling/flush'

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

@@ -62,6 +62,7 @@ module Datadog
               cached = payload[:cached] || (payload[:name] == PAYLOAD_CACHE)
 
               span.set_tag(Ext::TAG_DB_VENDOR, adapter_name)
+              span.set_tag(Contrib::Ext::DB::TAG_INSTANCE, config[:database])
               span.set_tag(Ext::TAG_DB_NAME, config[:database])
               span.set_tag(Ext::TAG_DB_CACHED, cached) if cached
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, config[:host]) if config[:host]

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/graphql/unified_trace.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'graphql/tracing'
+require 'graphql'
 
 module Datadog
   module Tracing

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
@@ -9,7 +13,6 @@ module Datadog
           module_function
 
           def patch!(schemas, options)
-            require_relative 'unified_trace'
             if schemas.empty?
               ::GraphQL::Schema.trace_with(UnifiedTrace, **options)
             else

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

@@ -20,6 +20,22 @@ 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.error(
+                '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/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