datadog 2.17.0 → 2.37.0

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

@@ -13,7 +13,7 @@ module Datadog
           # @public_api
           class Settings < Contrib::Configuration::Settings
             def initialize(options = {})
-              super(options)
+              super
 
               # NOTE: Eager load these
               #       Rails integration is responsible for orchestrating other integrations.
@@ -51,8 +51,11 @@ module Datadog
               end
             end
 
-            option :distributed_tracing, default: true, type: :bool
-
+            option :distributed_tracing do |o|
+              o.type :bool
+              o.env Ext::ENV_DISTRIBUTED_TRACING
+              o.default true
+            end
             option :request_queuing do |o|
               o.type :bool
               o.default false

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

@@ -9,10 +9,12 @@ module Datadog
         module Ext
           APP = 'rails'
           ENV_ENABLED = 'DD_TRACE_RAILS_ENABLED'
+          ENV_DISTRIBUTED_TRACING = 'DD_TRACE_RAILS_DISTRIBUTED_TRACING'
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAILS_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RAILS_ANALYTICS_SAMPLE_RATE'
-          ENV_DISABLE = 'DISABLE_DATADOG_RAILS'
+          # Note: Alias (previous name DISABLE_DATADOG_RAILS) defined in supported-configurations.json
+          ENV_DISABLE = 'DD_DISABLE_DATADOG_RAILS'
 
           SPAN_RUNNER_FILE = 'rails.runner.file'
           SPAN_RUNNER_INLINE = 'rails.runner.inline'

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

@@ -23,7 +23,7 @@ module Datadog
           register_as :rails, auto_patch: false
 
           def self.version
-            Gem.loaded_specs['railties'] && Gem.loaded_specs['railties'].version
+            Gem.loaded_specs['railties']&.version
           end
 
           def self.loaded?
@@ -35,7 +35,7 @@ module Datadog
           end
 
           def self.patchable?
-            super && !ENV.key?(Ext::ENV_DISABLE)
+            super && !DATADOG_ENV.key?(Ext::ENV_DISABLE)
           end
 
           def new_configuration

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

@@ -16,9 +16,9 @@ module Datadog
 
             app_config.log_tags ||= [] # Can be nil, we initialized it if so
             app_config.log_tags << proc { Tracing.log_correlation if Datadog.configuration.tracing.log_injection }
-          rescue StandardError => e
+          rescue => e
             Datadog.logger.warn(
-              "Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.class.name} #{e.message}"
+              "Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.class}: #{e.message}"
             )
             false
           end

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

@@ -26,15 +26,15 @@ module Datadog
           rescue Exception => e
             span = Tracing.active_span
             if !span.nil? && ActionPack::Utils.exception_is_error?(e)
-              # Only set error if it's supposed to be flagged as such
-              # e.g. we don't want to flag 404s.
+              # By default, only 5XX exceptions are actually errors (e.g. don't flag 404s).
+              # This can be changed by setting `DD_TRACE_HTTP_SERVER_ERROR_STATUSES` environment variable.
               # You can add custom errors via `config.action_dispatch.rescue_responses`
               span.set_error(e)
 
               # Some exception gets handled by Rails middleware before it can be set on Rack middleware
               # The rack span is the root span of the request and should make sure it has the full exception
               # set on it.
-              env[Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN].set_error(e) if env[Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN]
+              env[Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN]&.set_error(e)
             end
             raise e
           end

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

@@ -6,7 +6,6 @@ require_relative 'framework'
 require_relative 'log_injection'
 require_relative 'middlewares'
 require_relative 'runner'
-require_relative '../../../core/contrib/rails/utils'
 require_relative '../semantic_logger/patcher'
 
 module Datadog
@@ -86,7 +85,10 @@ module Datadog
 
           # Instruments the `bin/rails runner` command.
           def patch_rails_runner
-            ::Rails::Command.singleton_class.prepend(Command) if defined?(::Rails::Command)
+            # The `RunnerCommand` class is only available in Rails 5.1 and later.
+            if defined?(::Rails::Command::RunnerCommand) && Integration.version >= Gem::Version.new('5.1')
+              ::Rails::Command::RunnerCommand.prepend(Runner)
+            end
           end
         end
       end

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

@@ -10,35 +10,50 @@ module Datadog
         # * `-`: for code provided through the STDIN.
         # * File path: for code provided through a local file.
         # * `inline code`: for code provided directly as a command line argument.
+        #
+        # The difficulty in instrumenting the Rails Runner is that
+        # the Rails application (and as a consequence the Datadog tracing library)
+        # is loaded very late in the runner execution.
+        # The Rails application is loaded inside the same method the method
+        # that directly executes the code the user wants the runner to execute:
+        #
+        # ```ruby
+        # def perform(code_or_file = nil, *command_argv)
+        #   boot_application! # Loads the Rails and Datadog
+        #
+        #   if code_or_file == "-"
+        #     eval($stdin.read, TOPLEVEL_BINDING, "stdin") # Calls the user code for this Runner
+        #   # ...
+        # ```
+        #
+        # This means that there's no time to instrument the calling method, `perform`, which
+        # would be ideal. Instead, we resort to instrumenting `eval` and `load`, but
+        # only for calls from the `Rails::Command::RunnerCommand` class.
+        #
         # @see https://guides.rubyonrails.org/v6.1/command_line.html#bin-rails-runner
         module Runner
           # Limit the maximum size of the source code captured in the source tag.
           MAX_TAG_VALUE_SIZE = 4096
           private_constant :MAX_TAG_VALUE_SIZE
 
-          def runner(code_or_file = nil, *_command_argv)
-            if code_or_file == '-'
+          # Instruments the `Kernel.eval` method, but only for the
+          # `Rails::Command::RunnerCommand` class.
+          def eval(*args)
+            source = args[0]
+
+            if args[2] == 'stdin'
               name = Ext::SPAN_RUNNER_STDIN
-              resource = nil
               operation = Ext::TAG_OPERATION_STDIN
-              # The source is not yet available for STDIN, but it will be captured in `eval`.
-            elsif File.exist?(code_or_file)
-              name = Ext::SPAN_RUNNER_FILE
-              resource = code_or_file
-              operation = Ext::TAG_OPERATION_FILE
-              source = File.read(code_or_file)
             else
               name = Ext::SPAN_RUNNER_INLINE
-              resource = nil
               operation = Ext::TAG_OPERATION_INLINE
-              source = code_or_file
             end
 
             Tracing.trace(
               name,
               service: Datadog.configuration.tracing[:rails][:service_name],
-              resource: resource,
               tags: {
+                Tracing::Metadata::Ext::TAG_SVC_SRC => Ext::TAG_COMPONENT,
                 Tracing::Metadata::Ext::TAG_COMPONENT => Ext::TAG_COMPONENT,
                 Tracing::Metadata::Ext::TAG_OPERATION => operation,
               }
@@ -55,39 +70,48 @@ module Datadog
             end
           end
 
-          # Capture the executed source code when provided from STDIN.
-          def eval(*args)
-            span = Datadog::Tracing.active_span
-            if span&.name == Ext::SPAN_RUNNER_STDIN
-              source = args[0]
-              span.set_tag(
-                Ext::TAG_RUNNER_SOURCE,
-                Core::Utils.truncate(source, MAX_TAG_VALUE_SIZE)
-              )
-            end
-
-            super
+          def self.prepended(base)
+            base.const_set(:Kernel, InstrumentedKernel)
           end
 
-          ruby2_keywords :eval if respond_to?(:ruby2_keywords, true)
-        end
+          # Instruments the `Kernel.load` method, but only for the
+          # `Rails::Command::RunnerCommand` class.
+          module InstrumentedKernel
+            def self.load(*args)
+              file = args[0]
+              name = Ext::SPAN_RUNNER_FILE
+              resource = file
+              operation = Ext::TAG_OPERATION_FILE
+
+              begin
+                # Reads one more byte than the limit to allow us to check if the source exceeds the limit.
+                source = File.read(file, MAX_TAG_VALUE_SIZE + 1)
+              rescue => e
+                Datadog.logger.debug { "Failed to read file '#{file}' for Rails runner: #{e.class}: #{e.message}" }
+              end
 
-        # The instrumentation target, {Rails::Command::RunnerCommand} is only loaded
-        # right before `bin/rails runner` is executed. This means there's not much
-        # opportunity to patch it ahead of time.
-        # To ensure we can patch it successfully, we patch it's caller, {Rails::Command}
-        # and promptly patch {Rails::Command::RunnerCommand} when it is loaded.
-        module Command
-          def find_by_namespace(*args)
-            ret = super
-            # Patch RunnerCommand if it is loaded and not already patched.
-            if defined?(::Rails::Command::RunnerCommand) && !(::Rails::Command::RunnerCommand < Runner)
-              ::Rails::Command::RunnerCommand.prepend(Runner)
+              Tracing.trace(
+                name,
+                service: Datadog.configuration.tracing[:rails][:service_name],
+                resource: resource,
+                tags: {
+                  Tracing::Metadata::Ext::TAG_SVC_SRC => Ext::TAG_COMPONENT,
+                  Tracing::Metadata::Ext::TAG_COMPONENT => Ext::TAG_COMPONENT,
+                  Tracing::Metadata::Ext::TAG_OPERATION => operation,
+                }
+              ) do |span|
+                if source
+                  span.set_tag(
+                    Ext::TAG_RUNNER_SOURCE,
+                    Core::Utils.truncate(source, MAX_TAG_VALUE_SIZE)
+                  )
+                end
+                Contrib::Analytics.set_rate!(span, Datadog.configuration.tracing[:rails])
+
+                super
+              end
             end
-            ret
           end
-
-          ruby2_keywords :find_by_namespace if respond_to?(:ruby2_keywords, true)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative 'ext'
-require_relative '../utils/quantization/hash'
+require_relative '../utils/quantization/hash_formatter'
 
 module Datadog
   module Tracing
@@ -53,6 +53,7 @@ module Datadog
 
             def annotate_invoke!(span, args)
               span.resource = name
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               # Set analytics sample rate
               if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
                 Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
@@ -65,31 +66,32 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_INVOKE)
               span.set_tag(Ext::TAG_TASK_ARG_NAMES, arg_names)
               span.set_tag(Ext::TAG_INVOKE_ARGS, quantize_args(args)) unless args.nil?
-            rescue StandardError => e
-              Datadog.logger.debug("Error while tracing Rake invoke: #{e.class.name} #{e.message}")
+            rescue => e
+              Datadog.logger.debug { "Error while tracing Rake invoke: #{e.class}: #{e.message}" }
             end
 
             def annotate_execute!(span, args)
               span.resource = name
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_EXECUTE)
               span.set_tag(Ext::TAG_EXECUTE_ARGS, quantize_args(args.to_hash)) unless args.nil?
-            rescue StandardError => e
-              Datadog.logger.debug("Error while tracing Rake execute: #{e.class.name} #{e.message}")
+            rescue => e
+              Datadog.logger.debug { "Error while tracing Rake execute: #{e.class}: #{e.message}" }
             end
 
             def quantize_args(args)
               quantize_options = configuration[:quantize][:args]
-              Contrib::Utils::Quantization::Hash.format(args, quantize_options)
+              Contrib::Utils::Quantization::HashFormatter.format(args, quantize_options)
             end
 
             def enabled?
-              Datadog.configuration.tracing.enabled && \
+              Datadog.configuration.tracing.enabled &&
                 configuration[:enabled] == true
             end
 
             def span_options
-              { service: configuration[:service_name] }
+              {service: configuration[:service_name]}
             end
 
             def configuration

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

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

data/lib/datadog/tracing/contrib/redis/configuration/resolver.rb

@@ -19,13 +19,13 @@ module Datadog
             protected
 
             def parse_matcher(matcher)
-              matcher = { url: matcher } if matcher.is_a?(String)
+              matcher = {url: matcher} if matcher.is_a?(String)
 
               normalize(connection_resolver.resolve(matcher))
             end
 
             def normalize(hash)
-              return { url: hash[:url] } if hash[:scheme] == UNIX_SCHEME
+              return {url: hash[:url]} if hash[:scheme] == UNIX_SCHEME
 
               # Connexion strings are always converted to host, port, db and scheme
               # but the host, port, db and scheme will generate the :url only after

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

@@ -24,10 +24,11 @@ module Datadog
           TAG_OPERATION_COMMAND = 'command'
           TAG_SYSTEM = 'redis'
           TAG_DATABASE_INDEX = 'db.redis.database_index'
-          PEER_SERVICE_SOURCES = Array[
+          PEER_SERVICE_SOURCES = [
             Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
             Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
-            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,
+          ].freeze
         end
       end
     end

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

@@ -31,11 +31,11 @@ module Datadog
           end
 
           def self.redis_version
-            Gem.loaded_specs['redis'] && Gem.loaded_specs['redis'].version
+            Gem.loaded_specs['redis']&.version
           end
 
           def self.redis_client_version
-            Gem.loaded_specs['redis-client'] && Gem.loaded_specs['redis-client'].version
+            Gem.loaded_specs['redis-client']&.version
           end
 
           def self.loaded?

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

@@ -30,7 +30,7 @@ module Datadog
                 # For `redis-rb` 3.x
                 return client if respond_to?(:client)
 
-                Datadog.logger.warn 'Fail to apply configuration on redis client instance with '  \
+                Datadog.logger.warn 'Fail to apply configuration on redis client instance with ' \
                                                         '`Datadog.configure_onto(redis)`.'
 
                 # Null object instead of raising error
@@ -49,8 +49,8 @@ module Datadog
             module InstanceMethods
               def datadog_pin=(_pin)
                 Datadog.logger.warn \
-                  '`Datadog.configure_onto(redis)` is not supported on Redis 5+. To instrument '\
-                  "a redis instance with custom configuration, please initialize it with:\n"\
+                  '`Datadog.configure_onto(redis)` is not supported on Redis 5+. To instrument ' \
+                  "a redis instance with custom configuration, please initialize it with:\n" \
                   "  `Redis.new(..., custom: { datadog: { service_name: 'my-service' } })`.\n\n" \
                   'See: https://github.com/DataDog/dd-trace-rb/blob/master/docs/GettingStarted.md#redis'
               end
@@ -61,7 +61,7 @@ module Datadog
 
           def default_tags
             [].tap do |tags|
-              tags << "target_redis_version:#{Integration.redis_version}"               if Integration.redis_version
+              tags << "target_redis_version:#{Integration.redis_version}" if Integration.redis_version
               tags << "target_redis_client_version:#{Integration.redis_client_version}" if Integration.redis_client_version
             end
           end

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

@@ -34,7 +34,7 @@ module Datadog
             str = Core::Utils.utf8_encode(arg, binary: true, placeholder: PLACEHOLDER)
             Core::Utils.truncate(str, VALUE_MAX_LEN, TOO_LONG_MARK)
           rescue => e
-            Datadog.logger.debug("non formattable Redis arg #{str}: #{e}")
+            Datadog.logger.debug("non formattable Redis arg #{str}: #{e.class}: #{e.message}")
             PLACEHOLDER
           end
 
@@ -43,7 +43,7 @@ module Datadog
             return 'AUTH ?' if auth_command?(command_args)
 
             verb, *args = command_args.map { |x| format_arg(x) }
-            Core::Utils.truncate("#{verb.upcase} #{args.join(' ')}", CMD_MAX_LEN, TOO_LONG_MARK)
+            Core::Utils.truncate("#{verb.upcase} #{args.join(" ")}", CMD_MAX_LEN, TOO_LONG_MARK)
           end
 
           def get_verb(command_args)

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

@@ -21,11 +21,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(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_COMMAND)
 
@@ -46,8 +41,8 @@ module Datadog
               span.set_tag Ext::TAG_RAW_COMMAND, raw_command
 
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
-            rescue StandardError => e
-              Datadog.logger.error(e.message)
+            rescue => e
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 

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

@@ -26,6 +26,7 @@ module Datadog
           class << self
             def call(client, command, service_name, command_args)
               Tracing.trace(Redis::Ext::SPAN_COMMAND, type: Redis::Ext::TYPE, service: service_name) do |span|
+                span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Redis::Ext::TAG_COMPONENT)
                 raw_command = get_command(command, true)
                 span.resource = command_args ? raw_command : get_command(command, false)
 
@@ -37,6 +38,7 @@ module Datadog
 
             def call_pipelined(client, commands, service_name, command_args)
               Tracing.trace(Redis::Ext::SPAN_COMMAND, type: Redis::Ext::TYPE, service: service_name) do |span|
+                span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Redis::Ext::TAG_COMPONENT)
                 raw_command = get_pipeline_commands(commands, true)
                 span.resource = command_args ? raw_command : get_pipeline_commands(commands, false)
 
@@ -62,10 +64,10 @@ module Datadog
             # Quantizes a multi-command Redis pipeline execution
             def get_pipeline_commands(commands, command_args)
               list = if command_args
-                       commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
-                     else
-                       commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
-                     end
+                commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
+              else
+                commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
+              end
 
               list.empty? ? '(none)' : list.join("\n")
             end

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

@@ -33,6 +33,17 @@ module Datadog
           def register_as(name, registry: Contrib::REGISTRY, auto_patch: false, **options)
             registry.add(name, new(name, **options), auto_patch)
           end
+
+          # Registers this `as` in the global tracer registry as an alias of `original_name`.
+          # Using `as` or `original_name` become interchangeable.
+          # The configuration object is shared between the two names.
+          # The patcher will only run once if both are activated.
+          def register_alias_for(original_name, as:, registry: Contrib::REGISTRY)
+            original = registry[original_name]
+            raise ArgumentError, "integration '#{original_name}' not registered" unless original
+
+            registry.add(as, original, false)
+          end
         end
 
         # Instance methods for registerable behavior

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

@@ -35,7 +35,7 @@ module Datadog
         def [](name)
           @mutex.synchronize do
             entry = @data[name]
-            entry.klass if entry
+            entry&.klass
           end
         end
 

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

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

data/lib/datadog/tracing/contrib/resque/resque_job.rb

@@ -35,6 +35,7 @@ module Datadog
             return yield unless datadog_configuration && Tracing.enabled?
 
             Tracing.trace(Ext::SPAN_JOB, **span_options) do |span|
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               span.resource = args.first.is_a?(Hash) && args.first['job_class'] || name
               span.type = Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
 
@@ -76,7 +77,7 @@ module Datadog
           end
 
           def span_options
-            { service: datadog_configuration[:service_name], on_error: datadog_configuration[:on_error] }
+            {service: datadog_configuration[:service_name], on_error: datadog_configuration[:on_error]}
           end
 
           def datadog_configuration

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

@@ -30,8 +30,11 @@ module Datadog
               o.default 1.0
             end
 
-            option :distributed_tracing, default: true, type: :bool
-
+            option :distributed_tracing do |o|
+              o.type :bool
+              o.env Ext::ENV_DISTRIBUTED_TRACING
+              o.default true
+            end
             option :service_name do |o|
               o.default do
                 Contrib::SpanAttributeSchema.fetch_service_name(

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

@@ -8,6 +8,7 @@ module Datadog
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
           ENV_ENABLED = 'DD_TRACE_REST_CLIENT_ENABLED'
+          ENV_DISTRIBUTED_TRACING = 'DD_TRACE_REST_CLIENT_DISTRIBUTED_TRACING'
           ENV_SERVICE_NAME = 'DD_TRACE_REST_CLIENT_SERVICE_NAME'
           ENV_PEER_SERVICE = 'DD_TRACE_REST_CLIENT_PEER_SERVICE'
           # @!visibility private
@@ -17,10 +18,11 @@ module Datadog
           SPAN_REQUEST = 'rest_client.request'
           TAG_COMPONENT = 'rest_client'
           TAG_OPERATION_REQUEST = 'request'
-          PEER_SERVICE_SOURCES = Array[
+          PEER_SERVICE_SOURCES = [
             Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
             Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
-            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,
+          ].freeze
         end
       end
     end

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

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

data/lib/datadog/tracing/contrib/rest_client/request_patch.rb

@@ -22,7 +22,7 @@ module Datadog
             def execute(&block)
               uri = URI.parse(url)
 
-              return super(&block) unless Tracing.enabled?
+              return super unless Tracing.enabled?
 
               datadog_trace_request(uri) do |_span, trace|
                 if Tracing::Distributed::PropagationPolicy.enabled?(
@@ -37,6 +37,7 @@ module Datadog
             end
 
             def datadog_tag_request(uri, span)
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               span.resource = method.to_s.upcase
 
               if datadog_configuration[:peer_service]
@@ -46,11 +47,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(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
 
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
@@ -99,18 +95,21 @@ module Datadog
                 end
               end
             rescue ::RestClient::ExceptionWithResponse => e
-              span.set_error(e) if Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(e.http_code)
+              # DEV-3.0: This was previously checking against a 500..599 range.
+              # To not introduce breaking change, this was changed to use `http_error_statuses.server`,
+              # but `rest_client` is a client library, this check should use `http_error_statuses.client` instead.
+              span.set_error(e) if Datadog.configuration.tracing.http_error_statuses.server.include?(e.http_code)
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, e.http_code)
 
               raise e
               # rubocop:disable Lint/RescueException
             rescue Exception => e
               # rubocop:enable Lint/RescueException
-              span.set_error(e) if span
+              span&.set_error(e)
 
               raise e
             ensure
-              span.finish if span
+              span&.finish
             end
 
             private

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

@@ -7,6 +7,7 @@ module Datadog
         # Roda integration constants
         module Ext
           APP = 'roda'
+          TAG_COMPONENT = 'roda'
           ENV_ENABLED = 'DD_TRACE_RODA_ENABLED'
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_RODA_ANALYTICS_ENABLED'