datadog 2.30.0 → 2.45.0

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../integration'
-require_relative 'configuration/settings'
-require_relative 'patcher'
+require_relative "../integration"
+require_relative "configuration/settings"
+require_relative "patcher"
 
 module Datadog
   module Tracing
@@ -15,13 +15,13 @@ module Datadog
           # v4 had a migration to `named_tags` instead of `payload`
           # and has been out for almost 5 years at this point
           # it's probably reasonable to nudge users to using modern ruby libs
-          MINIMUM_VERSION = Gem::Version.new('4.0.0')
+          MINIMUM_VERSION = Gem::Version.new("4.0.0")
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :semantic_logger
 
           def self.version
-            Gem.loaded_specs['semantic_logger']&.version
+            Gem.loaded_specs["semantic_logger"]&.version
           end
 
           def self.loaded?

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../patcher'
-require_relative 'instrumentation'
+require_relative "../patcher"
+require_relative "instrumentation"
 
 module Datadog
   module Tracing

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/settings'
-require_relative '../ext'
+require_relative "../../configuration/settings"
+require_relative "../ext"
 
 module Datadog
   module Tracing

data/lib/datadog/tracing/contrib/sequel/database.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative '../../metadata/ext'
-require_relative '../analytics'
-require_relative 'ext'
-require_relative 'utils'
+require_relative "../../metadata/ext"
+require_relative "../analytics"
+require_relative "ext"
+require_relative "utils"
 
 module Datadog
   module Tracing
@@ -26,9 +26,10 @@ module Datadog
                 span.service = Datadog.configuration_for(self, :service_name) \
                                 || Datadog.configuration.tracing[:sequel][:service_name] \
                                 || Contrib::SpanAttributeSchema.fetch_service_name(
-                                  '',
+                                  "",
                                   adapter_name
                                 )
+                span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
                 span.resource = opts[:query]
                 span.type = Tracing::Metadata::Ext::SQL::TYPE
                 Utils.set_common_tags(span, self)
@@ -45,11 +46,7 @@ module Datadog
             end
 
             def parse_opts(sql, opts)
-              db_opts = if ::Sequel::VERSION < '3.41.0' && self.class.to_s !~ /Dataset$/
-                @opts
-              elsif instance_variable_defined?(:@pool) && @pool
-                @pool.db.opts
-              end
+              db_opts = @pool.db.opts if instance_variable_defined?(:@pool) && @pool
               sql = sql.is_a?(::Sequel::SQL::Expression) ? literal(sql) : sql.to_s
 
               Utils.parse_opts(sql, opts, db_opts)

data/lib/datadog/tracing/contrib/sequel/dataset.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative '../../metadata/ext'
-require_relative '../analytics'
-require_relative 'ext'
-require_relative 'utils'
+require_relative "../../metadata/ext"
+require_relative "../analytics"
+require_relative "ext"
+require_relative "utils"
 
 module Datadog
   module Tracing
@@ -43,9 +43,10 @@ module Datadog
                 span.service = Datadog.configuration_for(db, :service_name) \
                                 || Datadog.configuration.tracing[:sequel][:service_name] \
                                 || Contrib::SpanAttributeSchema.fetch_service_name(
-                                  '',
+                                  "",
                                   adapter_name
                                 )
+                span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
                 span.resource = opts[:query]
                 span.type = Tracing::Metadata::Ext::SQL::TYPE
                 Utils.set_common_tags(span, db)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../ext"
+
 module Datadog
   module Tracing
     module Contrib
@@ -7,15 +9,17 @@ module Datadog
         # Sequel integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_SEQUEL_ENABLED'
+          ENV_ENABLED = "DD_TRACE_SEQUEL_ENABLED"
           # @!visibility private
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_SEQUEL_ANALYTICS_ENABLED'
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SEQUEL_ANALYTICS_SAMPLE_RATE'
-          SPAN_QUERY = 'sequel.query'
-          TAG_DB_VENDOR = 'sequel.db.vendor'
-          TAG_PREPARED_NAME = 'sequel.prepared.name'
-          TAG_COMPONENT = 'sequel'
-          TAG_OPERATION_QUERY = 'query'
+          ENV_ANALYTICS_ENABLED = "DD_TRACE_SEQUEL_ANALYTICS_ENABLED"
+          ENV_ANALYTICS_SAMPLE_RATE = "DD_TRACE_SEQUEL_ANALYTICS_SAMPLE_RATE"
+          SPAN_QUERY = "sequel.query"
+          TAG_DB_VENDOR = "sequel.db.vendor"
+          TAG_PREPARED_NAME = "sequel.prepared.name"
+          TAG_COMPONENT = "sequel"
+          TAG_OPERATION_QUERY = "query"
+          TAG_DB_NAME = "sequel.db.name"
+          PEER_SERVICE_SOURCES = ([TAG_DB_NAME] + Contrib::Ext::DB::PEER_SERVICE_SOURCES).freeze
         end
       end
     end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../integration'
-require_relative 'configuration/settings'
-require_relative 'patcher'
+require_relative "../integration"
+require_relative "configuration/settings"
+require_relative "patcher"
 
 module Datadog
   module Tracing
@@ -12,13 +12,13 @@ module Datadog
         class Integration
           include Contrib::Integration
 
-          MINIMUM_VERSION = Gem::Version.new('3.41')
+          MINIMUM_VERSION = Gem::Version.new("3.41")
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :sequel, auto_patch: false
 
           def self.version
-            Gem.loaded_specs['sequel']&.version
+            Gem.loaded_specs["sequel"]&.version
           end
 
           def self.loaded?

data/lib/datadog/tracing/contrib/sequel/jdbc_connection_string.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sequel
+        # Extracts connection metadata from JDBC connection strings.
+        module JDBCConnectionString
+          MAX_BYTES = 8_192
+
+          # Matches JDBC connection strings whose subname uses `[transport:]//host...`.
+          CONNECTION_STRING_PATTERN =
+            %r{\Ajdbc:[a-z][a-z0-9+.-]*:(?:[a-z][a-z0-9+.-]*:)?//(?<subname>.+)\z}im
+
+          # Extracts the host and port from a string.
+          # The host can be a multi-host value, a bracketed IPv6 host, or an ordinary host.
+          HOST_AND_PORT_PATTERN =
+            /\A(?:\[(?<ipv6_host>[^\[\]]+)\]|(?<host>[^,]+(?:,[^,]+)+|[^:]+))(?::(?<port>\d+))?\z/
+
+          DATABASE_PROPERTY_PATTERN =
+            /(?:\A|[&;])(?:databaseName|database)=(?<value>[^&;]+)/i
+          LIBRARIES_PROPERTY_PATTERN =
+            /(?:\A|[&;])libraries=,*(?<value>[^,&;]+)/i
+          DATABASE_PATH_DELIMITER_PATTERN = %r{[:@\[\]?&=#]}
+
+          private_constant :MAX_BYTES, :CONNECTION_STRING_PATTERN,
+            :DATABASE_PROPERTY_PATTERN, :LIBRARIES_PROPERTY_PATTERN,
+            :DATABASE_PATH_DELIMITER_PATTERN, :HOST_AND_PORT_PATTERN
+
+          class << self
+            # The returned Hash guarantees the existence of all keys,
+            # but Hash values can be `nil` when not parseable from the connection string.
+            #
+            # @param connection_string [String, nil] the JDBC connection string to parse
+            # @return [Hash{Symbol => String, nil}]
+            #   - `:host` — host value when the subname uses authority syntax: `//host[:port]`
+            #   - `:port` — port when the subname uses authority syntax: `//host[:port]`
+            #   - `:database` — best-effort database name
+            def parse(connection_string)
+              # @type var result: metadata
+              result = {host: nil, port: nil, database: nil}
+              return result unless connection_string.is_a?(String) && connection_string.valid_encoding?
+
+              if connection_string.bytesize > MAX_BYTES
+                # Strip userinfo before truncation. Otherwise, an `@` beyond the limit could be
+                # discarded and leave a credential prefix looking like a valid authority/host.
+                authority_marker = connection_string.index("//")
+                if authority_marker
+                  authority_start = authority_marker + 2
+                  authority_end = [
+                    connection_string.index("/", authority_start),
+                    connection_string.index(";", authority_start),
+                    connection_string.index("?", authority_start),
+                  ].compact.min || connection_string.length
+                  userinfo_end = connection_string.rindex("@", authority_end - 1)
+
+                  if userinfo_end && userinfo_end >= authority_start
+                    connection_string =
+                      # Steep: https://github.com/soutaro/steep/issues/1219
+                      connection_string[0...authority_start] + # steep:ignore NoMethod
+                      connection_string[(userinfo_end + 1)..-1].to_s
+                  end
+                end
+
+                # Keep one extra byte, then let `chop` safely remove multi-byte unicode characters.
+                if connection_string.bytesize > MAX_BYTES
+                  connection_string = connection_string.byteslice(0, MAX_BYTES + 1).chop
+                end
+              end
+
+              match = CONNECTION_STRING_PATTERN.match(connection_string)
+              return result unless match
+
+              # We start with: `host[:port][/database][;properties][?query]`.
+              subname = match[:subname]
+
+              # Extract `query` from the end, leaving `host[:port][/database][;properties]`.
+              subname, query_separator, query = subname.partition("?")
+              query = nil if query_separator.empty?
+
+              # Extract `properties` next, leaving `host[:port][/database]`.
+              subname, properties_separator, properties = subname.partition(";")
+              properties = nil if properties_separator.empty?
+
+              # Separate the authority (`host[:port]`) from the optional database path.
+              authority, path = subname.split("/", 2)
+              return result if authority.nil? || authority.empty?
+
+              host, port = host_and_port_from_authority(authority)
+              return result unless host
+
+              database = database_from_path(path) ||
+                database_from_properties(properties) || database_from_properties(query)
+
+              {host: host, port: port, database: database}
+            rescue Encoding::CompatibilityError, ArgumentError
+              result
+            end
+
+            private
+
+            def database_from_path(path)
+              return if path.nil? || path.empty?
+
+              database = path.split(DATABASE_PATH_DELIMITER_PATTERN, 2).first
+              return if database.nil? || database.empty?
+
+              database
+            end
+
+            def host_and_port_from_authority(authority)
+              # Discard optional `userinfo@`, retaining only `host[:port]`.
+              authority = authority.rpartition("@").last
+              return if authority.empty?
+
+              match = HOST_AND_PORT_PATTERN.match(authority)
+              return unless match
+
+              # Only one of `ipv6_host` or `host` will be populated.
+              host = match[:ipv6_host] || match[:host]
+              port = match[:port]
+
+              [host, port]
+            end
+
+            def database_from_properties(properties)
+              return unless properties
+
+              database = DATABASE_PROPERTY_PATTERN.match(properties)
+              return database[:value] if database
+
+              libraries = LIBRARIES_PROPERTY_PATTERN.match(properties)
+              libraries && libraries[:value]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../patcher'
-require_relative 'database'
-require_relative 'dataset'
+require_relative "../patcher"
+require_relative "database"
+require_relative "dataset"
 
 module Datadog
   module Tracing

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

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
-require_relative '../../metadata/ext'
-require_relative '../utils/database'
+require_relative "../../metadata/ext"
+require_relative "../utils/database"
+require_relative "ext"
+require_relative "jdbc_connection_string"
+require_relative "../ext"
+require_relative "../span_attribute_schema"
 
 module Datadog
   module Tracing
@@ -16,7 +20,7 @@ module Datadog
             def adapter_name(database)
               scheme = database.adapter_scheme.to_s
 
-              if scheme == 'jdbc'
+              if scheme == "jdbc"
                 # The subtype is more important in this case,
                 # otherwise all database adapters will be 'jdbc'.
                 database_type(database)
@@ -34,8 +38,8 @@ module Datadog
 
             def parse_opts(sql, opts, db_opts, dataset = nil)
               # Prepared statements don't provide their sql query in the +sql+ parameter.
-              if !sql.is_a?(String) && (dataset&.respond_to?(:prepared_sql) &&
-                (resolved_sql = dataset.prepared_sql))
+              if !sql.is_a?(String) && dataset&.respond_to?(:prepared_sql) &&
+                  (resolved_sql = dataset.prepared_sql)
                 # The dataset contains the resolved SQL query and prepared statement name.
                 prepared_name = dataset.prepared_statement_name
                 sql = resolved_sql
@@ -46,31 +50,114 @@ module Datadog
                 query: sql,
                 prepared_name: prepared_name,
                 database: db_opts[:database],
-                host: db_opts[:host]
+                host: db_opts[:host],
               }
             end
 
             def set_common_tags(span, db)
-              # 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(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_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
+              span.set_tag(Contrib::Ext::DB::TAG_SYSTEM, database_type(db))
+
+              metadata = connection_metadata(db)
 
-              # TODO: Extract host for Sequel with JDBC. The easiest way seem to be through
-              # TODO: the database URI. Unfortunately, JDBC URIs do not work with `URI.parse`.
-              # host, _port = extract_host_port_from_uri(db.uri)
-              # span.set_tag(Tracing::Metadata::Ext::TAG_DESTINATION_NAME, host)
-              span.set_tag(Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME, db.opts[:host]) if db.opts[:host]
+              peer_metadata = false
+
+              # Embedded/hostless databases (e.g. SQLite) have no network peer; skip peer-identifying tags.
+              if metadata[:host] && !metadata[:host].empty?
+                span.set_tag(Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME, metadata[:host])
+                span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, metadata[:host])
+                span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, metadata[:host])
+                span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, metadata[:port]) if metadata[:port]
+                peer_metadata = true
+              end
+
+              if metadata[:database] && !metadata[:database].empty?
+                span.set_tag(Contrib::Ext::DB::TAG_INSTANCE, metadata[:database])
+                span.set_tag(Ext::TAG_DB_NAME, metadata[:database])
+                peer_metadata = true
+              end
+
+              if peer_metadata
+                Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+              end
 
               # Set analytics sample rate
               Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
             end
 
+            # Resolves the connection host/port/database for a Sequel::Database. For Sequel's
+            # JDBC adapter (used on JRuby), metadata is parsed from the JDBC connection string
+            # regardless of whether opts[:host] is set.
+            def connection_metadata(db)
+              opts = db.opts || {}
+              host = opts[:host]
+              port = opts[:port]
+              database = opts[:database]
+
+              # A JDBC connection string (in :uri, :url, or :database) can carry credentials, so
+              # always emit only parsed metadata -- never the raw connection string.
+              connection_string = opts[:uri] || opts[:url] || opts[:database]
+              is_jdbc = connection_string.is_a?(String) &&
+                connection_string.byteslice(0, 5)&.casecmp("jdbc:") == 0
+              if is_jdbc
+                parsed = JDBCConnectionString.parse(connection_string)
+
+                # JNDI/DataSource-managed connections keep only a lookup name in opts (e.g.
+                # "jdbc:jndi:..."), so nothing can be parsed from it. Recover the endpoint from the
+                # live connection's JDBC metadata, the same way Sequel resolves JNDI. This stays a
+                # fallback rather than the primary source: it requires a connection checkout and
+                # some drivers report no connection string, whereas the opts value is free and
+                # already present for direct connections (and non-JDBC adapters have no such
+                # metadata at all).
+                if parsed[:host].nil? && parsed[:port].nil? && parsed[:database].nil?
+                  fallback_metadata = jdbc_metadata_from_connection(db)
+                  parsed = fallback_metadata if fallback_metadata
+                end
+
+                # Sequel's JDBC adapter connects with the connection string and ignores separate
+                # :host/:port options, unlike native adapters where those options take precedence.
+                if parsed[:host] || parsed[:port] || parsed[:database]
+                  host = parsed[:host]
+                  port = parsed[:port]
+                end
+                database = parsed[:database]
+              end
+
+              {host: host, port: port&.to_s, database: database}
+            end
+
             private
 
+            # Resolves host/port/database from the live connection's JDBC metadata
+            # (java.sql.DatabaseMetaData#getURL), for JNDI/DataSource connections whose opts hold
+            # only a lookup name. Returns the parsed metadata, or nil when it can't be resolved.
+            #
+            # Only *parsed, credential-free* metadata is memoized -- the raw connection string is
+            # used transiently and never stored or logged. A completed lookup that yields no usable
+            # connection string is a permanent property of the connection, so it is cached to avoid
+            # re-checking out a connection on every query. A raised error is treated as transient
+            # (pool checkout timeout, dropped connection, ...) and left uncached, so a later query
+            # can retry once connectivity recovers.
+            def jdbc_metadata_from_connection(db)
+              return db.instance_variable_get(:@datadog_jdbc_metadata) if db.instance_variable_defined?(:@datadog_jdbc_metadata)
+
+              connection_string =
+                begin
+                  db.synchronize do |conn|
+                    conn.get_meta_data.get_url if conn.respond_to?(:get_meta_data)
+                  end
+                rescue => e
+                  Datadog.logger.debug { "Sequel: unable to resolve JDBC connection metadata (#{e.class})" }
+                  return nil
+                end
+
+              metadata = connection_string && JDBCConnectionString.parse(connection_string)
+              db.instance_variable_set(:@datadog_jdbc_metadata, metadata)
+              metadata
+            end
+
             def datadog_configuration
               Datadog.configuration.tracing[:sequel]
             end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/settings'
-require_relative '../ext'
+require_relative "../../configuration/settings"
+require_relative "../ext"
 
 module Datadog
   module Tracing

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

@@ -7,19 +7,19 @@ module Datadog
         # Shoryuken integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_SHORYUKEN_ENABLED'
+          ENV_ENABLED = "DD_TRACE_SHORYUKEN_ENABLED"
           # @!visibility private
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_SHORYUKEN_ANALYTICS_ENABLED'
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SHORYUKEN_ANALYTICS_SAMPLE_RATE'
-          SERVICE_NAME = 'shoryuken'
-          SPAN_JOB = 'shoryuken.job'
-          TAG_JOB_ID = 'shoryuken.id'
-          TAG_JOB_QUEUE = 'shoryuken.queue'
-          TAG_JOB_ATTRIBUTES = 'shoryuken.attributes'
-          TAG_JOB_BODY = 'shoryuken.body'
-          TAG_COMPONENT = 'shoryuken'
-          TAG_OPERATION_JOB = 'job'
-          TAG_MESSAGING_SYSTEM = 'amazonsqs'
+          ENV_ANALYTICS_ENABLED = "DD_TRACE_SHORYUKEN_ANALYTICS_ENABLED"
+          ENV_ANALYTICS_SAMPLE_RATE = "DD_TRACE_SHORYUKEN_ANALYTICS_SAMPLE_RATE"
+          SERVICE_NAME = "shoryuken"
+          SPAN_JOB = "shoryuken.job"
+          TAG_JOB_ID = "shoryuken.id"
+          TAG_JOB_QUEUE = "shoryuken.queue"
+          TAG_JOB_ATTRIBUTES = "shoryuken.attributes"
+          TAG_JOB_BODY = "shoryuken.body"
+          TAG_COMPONENT = "shoryuken"
+          TAG_OPERATION_JOB = "job"
+          TAG_MESSAGING_SYSTEM = "amazonsqs"
         end
       end
     end

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative '../integration'
-require_relative 'ext'
-require_relative 'configuration/settings'
-require_relative 'patcher'
+require_relative "../integration"
+require_relative "ext"
+require_relative "configuration/settings"
+require_relative "patcher"
 
 module Datadog
   module Tracing
@@ -13,13 +13,13 @@ module Datadog
         class Integration
           include Contrib::Integration
 
-          MINIMUM_VERSION = Gem::Version.new('3.2')
+          MINIMUM_VERSION = Gem::Version.new("3.2")
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :shoryuken
 
           def self.version
-            Gem.loaded_specs['shoryuken']&.version
+            Gem.loaded_specs["shoryuken"]&.version
           end
 
           def self.loaded?

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'tracer'
+require_relative "tracer"
 
 module Datadog
   module Tracing

data/lib/datadog/tracing/contrib/shoryuken/tracer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../analytics'
+require_relative "../analytics"
 
 module Datadog
   module Tracing
@@ -20,6 +20,7 @@ module Datadog
               type: Tracing::Metadata::Ext::AppTypes::TYPE_WORKER,
               on_error: @on_error
             ) do |span|
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_MESSAGING_SYSTEM)
 
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
@@ -50,7 +51,7 @@ module Datadog
           def resource(worker_instance, body)
             # If it's a Hash, try to get the job class from it.
             # This is for ActiveJob compatibility.
-            job_class = body['job_class'] if body.is_a?(Hash)
+            job_class = body["job_class"] if body.is_a?(Hash)
             # If nothing is available, use the worker class name.
             job_class || worker_instance.class.name
           end

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

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative '../../metadata/ext'
-require_relative '../analytics'
-require_relative 'distributed/propagation'
-require_relative 'ext'
-require_relative 'utils'
+require_relative "../../metadata/ext"
+require_relative "../analytics"
+require_relative "distributed/propagation"
+require_relative "ext"
+require_relative "utils"
 
 module Datadog
   module Tracing
@@ -24,6 +24,7 @@ module Datadog
             resource = job_resource(job)
 
             Datadog::Tracing.trace(Ext::SPAN_PUSH, service: @sidekiq_service) do |span, trace_op|
+              span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               if Tracing::Distributed::PropagationPolicy.enabled?(
                 global_config: configuration,
                 trace: trace_op
@@ -47,9 +48,9 @@ module Datadog
               if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
                 Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
               end
-              span.set_tag(Ext::TAG_JOB_ID, job['jid'])
-              span.set_tag(Ext::TAG_JOB_QUEUE, job['queue'])
-              span.set_tag(Ext::TAG_JOB_WRAPPER, job['class']) if job['wrapped']
+              span.set_tag(Ext::TAG_JOB_ID, job["jid"])
+              span.set_tag(Ext::TAG_JOB_QUEUE, job["queue"])
+              span.set_tag(Ext::TAG_JOB_WRAPPER, job["class"]) if job["wrapped"]
 
               yield
             end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/settings'
-require_relative '../ext'
+require_relative "../../configuration/settings"
+require_relative "../ext"
 
 module Datadog
   module Tracing