datadog 2.17.0 → 2.37.0

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        module Instrumentation
+          # Instrumentation for Kafka::Consumer
+          module Consumer
+            def self.prepended(base)
+              base.prepend(InstanceMethods)
+            end
+
+            # Instance methods for consumer instrumentation
+            module InstanceMethods
+              def each_message(**kwargs, &block)
+                return super unless Datadog::DataStreams.enabled?
+
+                wrapped_block = proc do |message|
+                  Datadog.logger.debug { "Kafka each_message: DSM enabled for topic #{message.topic}" }
+
+                  begin
+                    headers = message.headers || {}
+                    Datadog::DataStreams.set_consume_checkpoint(
+                      type: 'kafka',
+                      source: message.topic,
+                      auto_instrumentation: true
+                    ) { |key| headers[key] }
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e.message}")
+                  end
+
+                  yield(message) if block
+                end
+
+                super(**kwargs, &wrapped_block)
+              end
+
+              def each_batch(**kwargs, &block)
+                return super unless Datadog::DataStreams.enabled?
+
+                wrapped_block = proc do |batch|
+                  Datadog.logger.debug { "Kafka each_batch: DSM enabled for topic #{batch.topic}" }
+
+                  begin
+                    Datadog::DataStreams.set_consume_checkpoint(
+                      type: 'kafka',
+                      source: batch.topic,
+                      auto_instrumentation: true
+                    )
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e.message}")
+                  end
+
+                  yield(batch) if block
+                end
+
+                super(**kwargs, &wrapped_block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        module Instrumentation
+          # Instrumentation for Kafka::Producer
+          module Producer
+            def self.prepended(base)
+              base.prepend(InstanceMethods)
+            end
+
+            module InstanceMethods
+              def deliver_messages(**kwargs)
+                if Datadog::DataStreams.enabled?
+                  begin
+                    pending_messages = instance_variable_get(:@pending_message_queue)
+
+                    if pending_messages && !pending_messages.empty?
+                      pending_messages.each do |message|
+                        message.headers ||= {}
+                        Datadog::DataStreams.set_produce_checkpoint(
+                          type: 'kafka',
+                          destination: message.topic,
+                          auto_instrumentation: true
+                        ) do |key, value|
+                          message.headers[key] = value
+                        end
+                      end
+                    end
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e.message}")
+                  end
+                end
+
+                super
+              end
+
+              def send_messages(messages, **kwargs)
+                if Datadog::DataStreams.enabled?
+                  begin
+                    messages.each do |message|
+                      message[:headers] ||= {}
+                      Datadog::DataStreams.set_produce_checkpoint(
+                        type: 'kafka',
+                        destination: message[:topic],
+                        auto_instrumentation: true
+                      ) do |key, value|
+                        message[:headers][key] = value
+                      end
+                    end
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e.message}")
+                  end
+                end
+
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/kafka/integration.rb

@@ -21,7 +21,7 @@ module Datadog
           end
 
           def self.version
-            Gem.loaded_specs['ruby-kafka'] && Gem.loaded_specs['ruby-kafka'].version
+            Gem.loaded_specs['ruby-kafka']&.version
           end
 
           def self.loaded?

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

@@ -21,6 +21,20 @@ module Datadog
           def patch
             # Subscribe to Kafka events
             Events.subscribe!
+
+            # Apply monkey patches for additional instrumentation (e.g., DSM)
+            patch_producer if defined?(::Kafka::Producer)
+            patch_consumer if defined?(::Kafka::Consumer)
+          end
+
+          def patch_producer
+            require_relative 'instrumentation/producer'
+            ::Kafka::Producer.prepend(Instrumentation::Producer)
+          end
+
+          def patch_consumer
+            require_relative 'instrumentation/consumer'
+            ::Kafka::Consumer.prepend(Instrumentation::Consumer)
           end
         end
       end

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

@@ -18,7 +18,11 @@ module Datadog
 
             option :service_name
 
-            option :distributed_tracing, default: false, type: :bool
+            option :distributed_tracing do |o|
+              o.type :bool
+              o.env Ext::ENV_DISTRIBUTED_TRACING
+              o.default false
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/karafka/distributed/propagation.rb

@@ -19,6 +19,7 @@ module Datadog
             def initialize(
               propagation_style_inject:,
               propagation_style_extract:,
+              propagation_behavior_extract:,
               propagation_extract_first:
             )
               super(
@@ -37,6 +38,7 @@ module Datadog
                 },
                 propagation_style_inject: propagation_style_inject,
                 propagation_style_extract: propagation_style_extract,
+                propagation_behavior_extract: propagation_behavior_extract,
                 propagation_extract_first: propagation_extract_first
               )
             end

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

@@ -6,6 +6,7 @@ module Datadog
       module Karafka
         module Ext
           ENV_ENABLED = 'DD_TRACE_KARAFKA_ENABLED'
+          ENV_DISTRIBUTED_TRACING = 'DD_TRACE_KARAFKA_DISTRIBUTED_TRACING'
 
           SPAN_MESSAGE_CONSUME = 'karafka.consume'
           SPAN_WORKER_PROCESS = 'worker.process'

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        # Karafka framework code, used to essentially:
+        # - handle configuration entries which are specific to Datadog tracing
+        # - instrument parts of the framework when needed
+        module Framework
+          def self.setup
+            Datadog.configure do |datadog_config|
+              karafka_config = datadog_config.tracing[:karafka]
+              activate_waterdrop!(datadog_config, karafka_config)
+            end
+          end
+
+          # Apply relevant configuration from Karafka to WaterDrop
+          def self.activate_waterdrop!(datadog_config, karafka_config)
+            datadog_config.tracing.instrument(
+              :waterdrop,
+              service_name: karafka_config[:service_name],
+              distributed_tracing: karafka_config[:distributed_tracing],
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -24,19 +24,19 @@ module Datadog
               consumer = job.executor.topic.consumer
 
               action = case job_type
-                       when 'Periodic', 'PeriodicNonBlocking'
-                         'tick'
-                       when 'Shutdown'
-                         'shutdown'
-                       when 'Revoked', 'RevokedNonBlocking'
-                         'revoked'
-                       when 'Idle'
-                         'idle'
-                       when 'Eofed', 'EofedNonBlocking'
-                         'eofed'
-                       else
-                         'consume'
-                       end
+              when 'Periodic', 'PeriodicNonBlocking'
+                'tick'
+              when 'Shutdown'
+                'shutdown'
+              when 'Revoked', 'RevokedNonBlocking'
+                'revoked'
+              when 'Idle'
+                'idle'
+              when 'Eofed', 'EofedNonBlocking'
+                'eofed'
+              else
+                'consume'
+              end
 
               span.resource = "#{consumer}##{action}"
 
@@ -47,6 +47,17 @@ module Datadog
                 span.set_tag(Ext::TAG_CONSUMER, consumer)
                 span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, job.executor.topic.name)
                 span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_SYSTEM)
+
+                # DSM: Track consumer offset stats for batch processing
+                if Datadog.configuration.data_streams.enabled
+                  job.messages.each do |message|
+                    Datadog::DataStreams.track_kafka_consume(
+                      job.executor.topic.name,
+                      job.executor.partition,
+                      message.metadata.offset
+                    )
+                  end
+                end
               end
 
               super

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

@@ -25,17 +25,34 @@ module Datadog
           # @see https://github.com/karafka/karafka/blob/b06d1f7c17818e1605f80c2bb573454a33376b40/README.md?plain=1#L29-L35
           def each(&block)
             @messages_array.each do |message|
-              if configuration[:distributed_tracing]
+              trace_digest = if configuration[:distributed_tracing]
                 headers = if message.metadata.respond_to?(:raw_headers)
-                            message.metadata.raw_headers
-                          else
-                            message.metadata.headers
-                          end
-                trace_digest = Karafka.extract(headers)
-                Datadog::Tracing.continue_trace!(trace_digest) if trace_digest
+                  message.metadata.raw_headers
+                else
+                  message.metadata.headers
+                end
+                Karafka.extract(headers)
               end
 
-              Tracing.trace(Ext::SPAN_MESSAGE_CONSUME) do |span|
+              Tracing.trace(Ext::SPAN_MESSAGE_CONSUME, continue_from: trace_digest) do |span, trace|
+                if Datadog::DataStreams.enabled?
+                  begin
+                    headers = if message.metadata.respond_to?(:raw_headers)
+                      message.metadata.raw_headers
+                    else
+                      message.metadata.headers
+                    end
+
+                    Datadog::DataStreams.set_consume_checkpoint(
+                      type: 'kafka',
+                      source: message.topic,
+                      auto_instrumentation: true
+                    ) { |key| headers[key] }
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e.message}")
+                  end
+                end
+
                 span.set_tag(Ext::TAG_OFFSET, message.metadata.offset)
                 span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, message.topic)
                 span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_SYSTEM)
@@ -52,6 +69,8 @@ module Datadog
         module Patcher
           include Contrib::Patcher
 
+          ACTIVATE_FRAMEWORK_ONLY_ONCE = Core::Utils::OnlyOnce.new
+
           module_function
 
           def target_version
@@ -60,9 +79,21 @@ module Datadog
 
           def patch
             require_relative 'monitor'
+            require_relative 'framework'
+            require_relative '../waterdrop'
 
             ::Karafka::Instrumentation::Monitor.prepend(Monitor)
             ::Karafka::Messages::Messages.prepend(MessagesPatch)
+
+            if Contrib::WaterDrop::Integration.compatible?
+              ::Karafka.monitor.subscribe('app.initialized') do |event|
+                ACTIVATE_FRAMEWORK_ONLY_ONCE.run do
+                  Contrib::Karafka::Framework.setup
+                end
+
+                Contrib::WaterDrop::Patcher.add_middleware(::Karafka.producer)
+              end
+            end
           end
         end
       end

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

@@ -28,6 +28,7 @@ module Datadog
           @propagation = Karafka::Distributed::Propagation.new(
             propagation_style_inject: tracing.propagation_style_inject,
             propagation_style_extract: tracing.propagation_style_extract,
+            propagation_behavior_extract: tracing.propagation_behavior_extract,
             propagation_extract_first: tracing.propagation_extract_first
           )
         end

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

@@ -16,7 +16,7 @@ module Datadog
               return super unless Datadog.configuration.tracing.log_injection
               return super unless Datadog.configuration.tracing[:lograge].enabled
 
-              original_custom_options = super(event)
+              original_custom_options = super
 
               # Retrieves trace information for current thread
               correlation = Tracing.correlation

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

@@ -18,7 +18,7 @@ module Datadog
           register_as :lograge
 
           def self.version
-            Gem.loaded_specs['lograge'] && Gem.loaded_specs['lograge'].version
+            Gem.loaded_specs['lograge']&.version
           end
 
           def self.loaded?

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

@@ -20,10 +20,12 @@ module Datadog
 
           # patch applies our patch
           def patch
+            # First check Lograge logger directly for when keep_original_rails_log option is used
+            used_logger = ::Lograge.logger || ::Lograge::LogSubscribers::ActionController.logger
+
             # 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)
+                used_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. ' \

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

@@ -11,7 +11,7 @@ module Datadog
           # Custom settings for the MongoDB integration
           # @public_api
           class Settings < Contrib::Configuration::Settings
-            DEFAULT_QUANTIZE = { show: [:collection, :database, :operation] }.freeze
+            DEFAULT_QUANTIZE = {show: [:collection, :database, :operation]}.freeze
 
             option :enabled do |o|
               o.type :bool

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

@@ -25,7 +25,7 @@ module Datadog
           TAG_COMPONENT = 'mongodb'
           TAG_OPERATION_COMMAND = 'command'
           TAG_SYSTEM = 'mongodb'
-          PEER_SERVICE_SOURCES = (Array[Ext::TAG_DB] + Contrib::Ext::DB::PEER_SERVICE_SOURCES).freeze
+          PEER_SERVICE_SOURCES = ([Ext::TAG_DB] + Contrib::Ext::DB::PEER_SERVICE_SOURCES).freeze
 
           # Temporary namespace to accommodate unified tags which has naming collision, before
           # making breaking changes

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

@@ -22,7 +22,7 @@ module Datadog
           end
 
           def self.version
-            Gem.loaded_specs['mongo'] && Gem.loaded_specs['mongo'].version
+            Gem.loaded_specs['mongo']&.version
           end
 
           def self.loaded?

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../utils/quantization/hash'
+require_relative '../utils/quantization/hash_formatter'
 
 module Datadog
   module Tracing
@@ -9,7 +9,7 @@ module Datadog
       module MongoDB
         EXCLUDE_KEYS = [:_id].freeze
         SHOW_KEYS = [].freeze
-        DEFAULT_OPTIONS = { exclude: EXCLUDE_KEYS, show: SHOW_KEYS }.freeze
+        DEFAULT_OPTIONS = {exclude: EXCLUDE_KEYS, show: SHOW_KEYS}.freeze
 
         module_function
 
@@ -20,11 +20,11 @@ module Datadog
         # returns a formatted and normalized query
         def query_builder(command_name, database_name, command)
           # always exclude the command name
-          options = Contrib::Utils::Quantization::Hash.merge_options(quantization_options, exclude: [command_name.to_s])
+          options = Contrib::Utils::Quantization::HashFormatter.merge_options(quantization_options, exclude: [command_name.to_s])
 
           # quantized statements keys are strings to avoid leaking Symbols in older Rubies
           # as Symbols are not GC'ed in Rubies prior to 2.2
-          base_info = Contrib::Utils::Quantization::Hash.format(
+          base_info = Contrib::Utils::Quantization::HashFormatter.format(
             {
               'operation' => command_name,
               'database' => database_name,
@@ -33,11 +33,11 @@ module Datadog
             options
           )
 
-          base_info.merge(Contrib::Utils::Quantization::Hash.format(command, options))
+          base_info.merge(Contrib::Utils::Quantization::HashFormatter.format(command, options))
         end
 
         def quantization_options
-          Contrib::Utils::Quantization::Hash.merge_options(DEFAULT_OPTIONS, configuration[:quantize])
+          Contrib::Utils::Quantization::HashFormatter.merge_options(DEFAULT_OPTIONS, configuration[:quantize])
         end
 
         def configuration

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

@@ -30,6 +30,8 @@ module Datadog
             span = Tracing.trace(Ext::SPAN_COMMAND, service: service, type: Ext::SPAN_TYPE_COMMAND)
             set_span(event, span)
 
+            span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
+
             # build a quantized Query using the Parser module
             query = MongoDB.query_builder(event.command_name, event.database_name, event.command)
             serialized_query = serialize_query(query)
@@ -41,11 +43,6 @@ module Datadog
               )
             end
 
-            # Tag original global service name if not used
-            if span.service != Datadog.configuration.service
-              span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
-            end
-
             span.set_tag(Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM)
 
             span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
@@ -72,8 +69,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}")
+          rescue => e
+            Datadog.logger.debug("error when handling MongoDB 'started' event: #{e.class}: #{e.message}")
           end
           # rubocop:enable Metrics/AbcSize
 
@@ -84,12 +81,12 @@ module Datadog
             # the failure is not a real exception because it's handled by
             # the framework itself, so we set only the error and the message
             span.set_error(event)
-          rescue StandardError => e
-            Datadog.logger.debug("error when handling MongoDB 'failed' event: #{e}")
+          rescue => 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
-            span.finish unless span.nil?
+            span&.finish
             clear_span(event)
           end
 
@@ -100,12 +97,12 @@ module Datadog
             # add fields that are available only after executing the query
             rows = event.reply.fetch('n', nil)
             span.set_tag(Ext::TAG_ROWS, rows) unless rows.nil?
-          rescue StandardError => e
-            Datadog.logger.debug("error when handling MongoDB 'succeeded' event: #{e}")
+          rescue => 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
-            span.finish unless span.nil?
+            span&.finish
             clear_span(event)
           end
 
@@ -118,7 +115,7 @@ module Datadog
               # Incorrect Hash#to_s serialization. The Mongo command should only be encoded as JSON.
               # This code path should be removed, and is only kept to avoid a breaking change.
               Datadog::Core.log_deprecation(key: :mongo_json_command) do
-                'MongoDB integration: `json_command: false` causes invalid command serialization. '\
+                'MongoDB integration: `json_command: false` causes invalid command serialization. ' \
                 'Use `json_command: true` or `DD_TRACE_MONGO_JSON_COMMAND=1` instead.'
               end
 

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

@@ -53,6 +53,12 @@ module Datadog
               o.default false
             end
 
+            option :inject_sql_basehash do |o|
+              o.type :bool
+              o.env Contrib::Propagation::SqlComment::Ext::ENV_DBM_INJECT_SQL_BASEHASH
+              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/ext.rb

@@ -20,7 +20,7 @@ module Datadog
           TAG_COMPONENT = 'mysql2'
           TAG_OPERATION_QUERY = 'query'
           TAG_SYSTEM = 'mysql'
-          PEER_SERVICE_SOURCES = (Array[Ext::TAG_DB_NAME] + Contrib::Ext::DB::PEER_SERVICE_SOURCES).freeze
+          PEER_SERVICE_SOURCES = ([Ext::TAG_DB_NAME] + Contrib::Ext::DB::PEER_SERVICE_SOURCES).freeze
         end
       end
     end

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

@@ -24,6 +24,7 @@ module Datadog
               on_error = Datadog.configuration_for(self, :on_error) || datadog_configuration[:on_error]
 
               Tracing.trace(Ext::SPAN_QUERY, service: service, on_error: on_error) do |span, trace_op|
+                span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
                 span.resource = sql
                 span.type = Tracing::Metadata::Ext::SQL::TYPE
 
@@ -34,27 +35,19 @@ module Datadog
                   )
                 end
 
-                # Tag original global service name if not used
-                if span.service != Datadog.configuration.service
-                  span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
-                end
-
                 span.set_tag(Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM)
                 span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
 
                 span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
                 span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_QUERY)
 
-                span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, query_options[:host])
+                tag_database_instance(span, query_options[:database])
+
+                set_span_tags(span, query_options)
 
                 # 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)
 
                 sql = inject_propagation(span, sql, trace_op)
@@ -68,7 +61,8 @@ module Datadog
             def inject_propagation(span, sql, trace_op)
               propagation_mode = Contrib::Propagation::SqlComment::Mode.new(
                 datadog_configuration[:comment_propagation],
-                datadog_configuration[:append_comment]
+                datadog_configuration[:append_comment],
+                datadog_configuration[:inject_sql_basehash]
               )
 
               Contrib::Propagation::SqlComment.annotate!(span, propagation_mode)
@@ -91,6 +85,19 @@ module Datadog
             def analytics_sample_rate
               datadog_configuration[:analytics_sample_rate]
             end
+
+            def tag_database_instance(span, database)
+              return if database.nil? || database.empty?
+
+              span.set_tag(Contrib::Ext::DB::TAG_INSTANCE, database)
+              span.set_tag(Ext::TAG_DB_NAME, database)
+            end
+
+            def set_span_tags(span, query_options)
+              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])
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, query_options[:host])
+            end
           end
         end
       end

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

@@ -18,7 +18,7 @@ module Datadog
           register_as :mysql2
 
           def self.version
-            Gem.loaded_specs['mysql2'] && Gem.loaded_specs['mysql2'].version
+            Gem.loaded_specs['mysql2']&.version
           end
 
           def self.loaded?