ddtrace 1.12.1 → 1.18.0

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

@@ -24,23 +24,24 @@ module Datadog
           end
 
           def patch
-            patch_before_intialize
-            patch_after_intialize
+            patch_before_initialize
+            patch_after_initialize
           end
 
-          def patch_before_intialize
+          def patch_before_initialize
             ::ActiveSupport.on_load(:before_initialize) do
-              Contrib::Rails::Patcher.before_intialize(self)
+              Contrib::Rails::Patcher.before_initialize(self)
             end
           end
 
-          def before_intialize(app)
+          def before_initialize(app)
             BEFORE_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
               # Middleware must be added before the application is initialized.
               # Otherwise the middleware stack will be frozen.
               # Sometimes we don't want to activate middleware e.g. OpenTracing, etc.
               add_middleware(app) if Datadog.configuration.tracing[:rails][:middleware]
-              add_logger(app) if Datadog.configuration.tracing.log_injection
+
+              Rails::LogInjection.configure_log_tags(app.config)
             end
           end
 
@@ -61,45 +62,13 @@ module Datadog
             app.middleware.insert_after(::ActionDispatch::DebugExceptions, Contrib::Rails::ExceptionMiddleware)
           end
 
-          def add_logger(app)
-            should_warn = true
-            # check if lograge key exists
-            # Note: Rails executes initializers sequentially based on alphabetical order,
-            # and lograge config could occur after datadog config.
-            # So checking for `app.config.lograge.enabled` may yield a false negative,
-            # and adding custom options naively if `config.lograge` exists from the lograge Railtie,
-            # is inconsistent since a lograge initializer would override it.
-            # Instead, we patch Lograge `custom_options` internals directly
-            # as part of Rails framework patching
-            # and just flag off the warning log here.
-            # SemanticLogger we similarly patch in the after_initiaize block, and should flag
-            # off the warning log here if we know we'll patch this gem later.
-            should_warn = false if app.config.respond_to?(:lograge) || defined?(::SemanticLogger)
-
-            # if lograge isn't set, check if tagged logged is enabled.
-            # if so, add proc that injects trace identifiers for tagged logging.
-            logger = app.config.logger || ::Rails.logger
-
-            if logger \
-                && defined?(::ActiveSupport::TaggedLogging) \
-                && logger.is_a?(::ActiveSupport::TaggedLogging)
-
-              Contrib::Rails::LogInjection.add_as_tagged_logging_logger(app)
-              should_warn = false
-            end
-
-            if should_warn
-              Datadog.logger.warn("Unable to enable Datadog Trace context, Logger #{logger.class} is not supported")
-            end
-          end
-
-          def patch_after_intialize
+          def patch_after_initialize
             ::ActiveSupport.on_load(:after_initialize) do
-              Contrib::Rails::Patcher.after_intialize(self)
+              Contrib::Rails::Patcher.after_initialize(self)
             end
           end
 
-          def after_intialize(app)
+          def after_initialize(app)
             AFTER_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
               # Finish configuring the tracer after the application is initialized.
               # We need to wait for some things, like application name, middleware stack, etc.

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

@@ -6,12 +6,12 @@ module Datadog
   # Railtie class initializes
   class Railtie < Rails::Railtie
     # Add the trace middleware to the application stack
-    initializer 'datadog.before_intialize' do |app|
-      Tracing::Contrib::Rails::Patcher.before_intialize(app)
+    initializer 'datadog.before_initialize' do |app|
+      Tracing::Contrib::Rails::Patcher.before_initialize(app)
     end
 
     config.after_initialize do
-      Tracing::Contrib::Rails::Patcher.after_intialize(self)
+      Tracing::Contrib::Rails::Patcher.after_initialize(self)
     end
   end
 end

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

@@ -14,21 +14,24 @@ module Datadog
           # @public_api
           class Settings < Contrib::Configuration::Settings
             option :enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
             end
 
             option :analytics_enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
             end
 
             option :analytics_sample_rate do |o|
-              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
-              o.lazy
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
             end
 
-            option :quantize, default: {}
+            option :quantize, default: {}, type: :hash
             option :service_name
 
             # A list of rake tasks, using their string names, to be instrumented.
@@ -36,9 +39,9 @@ module Datadog
             # Automatically instrumenting all Rake tasks can lead to long-running tasks
             # causing undue memory accumulation, as the trace for such tasks is never flushed.
             option :tasks do |o|
-              o.default { [] }
-              o.lazy
-              o.on_set do |value|
+              o.type :array
+              o.default []
+              o.after_set do |value|
                 # DEV: It should be possible to modify the value after it's set. E.g. for normalization.
                 options[:tasks].instance_variable_set(:@value, value.map(&:to_s).to_set)
               end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Tracing
     module Contrib
@@ -5,18 +7,18 @@ module Datadog
         # Rake integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_RAKE_ENABLED'.freeze
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAKE_ANALYTICS_ENABLED'.freeze
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RAKE_ANALYTICS_SAMPLE_RATE'.freeze
-          SERVICE_NAME = 'rake'.freeze
-          SPAN_INVOKE = 'rake.invoke'.freeze
-          SPAN_EXECUTE = 'rake.execute'.freeze
-          TAG_EXECUTE_ARGS = 'rake.execute.args'.freeze
-          TAG_INVOKE_ARGS = 'rake.invoke.args'.freeze
-          TAG_TASK_ARG_NAMES = 'rake.task.arg_names'.freeze
-          TAG_COMPONENT = 'rake'.freeze
-          TAG_OPERATION_EXECUTE = 'execute'.freeze
-          TAG_OPERATION_INVOKE = 'invoke'.freeze
+          ENV_ENABLED = 'DD_TRACE_RAKE_ENABLED'
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAKE_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RAKE_ANALYTICS_SAMPLE_RATE'
+          SERVICE_NAME = 'rake'
+          SPAN_INVOKE = 'rake.invoke'
+          SPAN_EXECUTE = 'rake.execute'
+          TAG_EXECUTE_ARGS = 'rake.execute.args'
+          TAG_INVOKE_ARGS = 'rake.invoke.args'
+          TAG_TASK_ARG_NAMES = 'rake.task.arg_names'
+          TAG_COMPONENT = 'rake'
+          TAG_OPERATION_EXECUTE = 'execute'
+          TAG_OPERATION_INVOKE = 'invoke'
         end
       end
     end

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

@@ -12,23 +12,27 @@ module Datadog
           # @public_api
           class Settings < Contrib::Configuration::Settings
             option :enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
             end
 
             option :analytics_enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
             end
 
             option :analytics_sample_rate do |o|
-              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
-              o.lazy
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
             end
 
             option :command_args do |o|
-              o.default { env_to_bool(Ext::ENV_COMMAND_ARGS, true) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_COMMAND_ARGS
+              o.default false
             end
 
             option :service_name do |o|
@@ -38,7 +42,11 @@ module Datadog
                   Ext::DEFAULT_PEER_SERVICE_NAME
                 )
               end
-              o.lazy
+            end
+
+            option :peer_service do |o|
+              o.type :string, nilable: true
+              o.env Ext::ENV_PEER_SERVICE
             end
           end
         end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Tracing
     module Contrib
@@ -5,21 +7,26 @@ module Datadog
         # Redis integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_REDIS_ENABLED'.freeze
-          ENV_SERVICE_NAME = 'DD_TRACE_REDIS_SERVICE_NAME'.freeze
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_REDIS_ANALYTICS_ENABLED'.freeze
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_REDIS_ANALYTICS_SAMPLE_RATE'.freeze
-          ENV_COMMAND_ARGS = 'DD_REDIS_COMMAND_ARGS'.freeze
-          METRIC_PIPELINE_LEN = 'redis.pipeline_length'.freeze
-          DEFAULT_PEER_SERVICE_NAME = 'redis'.freeze
-          SPAN_COMMAND = 'redis.command'.freeze
-          TAG_DB = 'out.redis_db'.freeze
-          TAG_RAW_COMMAND = 'redis.raw_command'.freeze
-          TYPE = 'redis'.freeze
-          TAG_COMPONENT = 'redis'.freeze
-          TAG_OPERATION_COMMAND = 'command'.freeze
-          TAG_SYSTEM = 'redis'.freeze
-          TAG_DATABASE_INDEX = 'db.redis.database_index'.freeze
+          ENV_ENABLED = 'DD_TRACE_REDIS_ENABLED'
+          ENV_SERVICE_NAME = 'DD_TRACE_REDIS_SERVICE_NAME'
+          ENV_PEER_SERVICE = 'DD_TRACE_REDIS_PEER_SERVICE'
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_REDIS_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_REDIS_ANALYTICS_SAMPLE_RATE'
+          ENV_COMMAND_ARGS = 'DD_REDIS_COMMAND_ARGS'
+          METRIC_PIPELINE_LEN = 'redis.pipeline_length'
+          DEFAULT_PEER_SERVICE_NAME = 'redis'
+          SPAN_COMMAND = 'redis.command'
+          TAG_DB = 'out.redis_db'
+          TAG_RAW_COMMAND = 'redis.raw_command'
+          TYPE = 'redis'
+          TAG_COMPONENT = 'redis'
+          TAG_OPERATION_COMMAND = 'command'
+          TAG_SYSTEM = 'redis'
+          TAG_DATABASE_INDEX = 'db.redis.database_index'
+          PEER_SERVICE_SOURCES = Array[
+            Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
+            Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
         end
       end
     end

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

@@ -3,6 +3,7 @@ require_relative 'configuration/resolver'
 require_relative 'ext'
 require_relative 'quantize'
 require_relative 'tags'
+require_relative 'trace_middleware'
 
 module Datadog
   module Tracing
@@ -17,31 +18,11 @@ module Datadog
           # InstanceMethods - implementing instrumentation
           module InstanceMethods
             def call(*args, &block)
-              show_command_args = command_args?
-
-              Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-                span.service = service_name
-                span.span_type = Contrib::Redis::Ext::TYPE
-                span.resource = get_command(args, show_command_args)
-                Contrib::Redis::Tags.set_common_tags(self, span, show_command_args)
-
-                super
-              end
+              TraceMiddleware.call(self, args[0], service_name, command_args?) { super }
             end
 
             def call_pipeline(*args, &block)
-              show_command_args = command_args?
-
-              Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-                span.service = service_name
-                span.span_type = Contrib::Redis::Ext::TYPE
-                commands = get_pipeline_commands(args, show_command_args)
-                span.resource = commands.any? ? commands.join("\n") : '(none)'
-                span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
-                Contrib::Redis::Tags.set_common_tags(self, span, show_command_args)
-
-                super
-              end
+              TraceMiddleware.call_pipelined(self, args[0].commands, service_name, command_args?) { super }
             end
 
             private
@@ -59,22 +40,6 @@ module Datadog
                 datadog_configuration[:service_name]
             end
 
-            def get_command(args, show_command_args)
-              if show_command_args
-                Contrib::Redis::Quantize.format_command_args(*args)
-              else
-                Contrib::Redis::Quantize.get_verb(*args)
-              end
-            end
-
-            def get_pipeline_commands(args, show_command_args)
-              if show_command_args
-                args[0].commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
-              else
-                args[0].commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
-              end
-            end
-
             def datadog_configuration
               Datadog.configuration.tracing[:redis, options]
             end

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

@@ -12,15 +12,22 @@ module Datadog
         # Tags handles generic common tags assignment.
         module Tags
           class << self
-            def set_common_tags(client, span, show_command_args)
-              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
-              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_COMMAND)
+            def set_common_tags(client, span, raw_command)
+              if datadog_configuration[:peer_service]
+                span.set_tag(
+                  Tracing::Metadata::Ext::TAG_PEER_SERVICE,
+                  datadog_configuration[:peer_service]
+                )
+              end
 
-              # Tag as an external peer service
-              if Contrib::SpanAttributeSchema.default_span_attribute_schema?
-                span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, span.service)
+              # 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)
+
               span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, client.host)
 
               span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
@@ -35,7 +42,9 @@ module Datadog
 
               span.set_tag Ext::TAG_DATABASE_INDEX, client.db.to_s
               span.set_tag Ext::TAG_DB, client.db
-              span.set_tag Ext::TAG_RAW_COMMAND, span.resource if show_command_args
+              span.set_tag Ext::TAG_RAW_COMMAND, raw_command
+
+              Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
             end
 
             private

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

@@ -9,55 +9,68 @@ module Datadog
       module Redis
         # Instrumentation for Redis 5+
         module TraceMiddleware
-          def call(commands, redis_config)
-            Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-              datadog_configuration = resolve(redis_config)
-              resource = get_command(commands, datadog_configuration[:command_args])
+          # Instruments {RedisClient::ConnectionMixin#call}.
+          def call(command, redis_config)
+            config = resolve(redis_config)
+            TraceMiddleware.call(redis_config, command, config[:service_name], config[:command_args]) { super }
+          end
+
+          # Instruments {RedisClient::ConnectionMixin#call_pipelined}.
+          def call_pipelined(commands, redis_config)
+            config = resolve(redis_config)
+            TraceMiddleware.call_pipelined(redis_config, commands, config[:service_name], config[:command_args]) { super }
+          end
 
-              span.service = datadog_configuration[:service_name]
-              span.span_type = Contrib::Redis::Ext::TYPE
-              span.resource = resource
+          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|
+                raw_command = get_command(command, true)
+                span.resource = command_args ? raw_command : get_command(command, false)
 
-              Contrib::Redis::Tags.set_common_tags(redis_config, span, datadog_configuration[:command_args])
+                Contrib::Redis::Tags.set_common_tags(client, span, raw_command)
 
-              super
+                yield
+              end
             end
-          end
 
-          def call_pipelined(commands, redis_config)
-            Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-              datadog_configuration = resolve(redis_config)
-              pipelined_commands = get_pipeline_commands(commands, datadog_configuration[:command_args])
+            def call_pipelined(client, commands, service_name, command_args)
+              Tracing.trace(Redis::Ext::SPAN_COMMAND, type: Redis::Ext::TYPE, service: service_name) do |span|
+                raw_command = get_pipeline_commands(commands, true)
+                span.resource = command_args ? raw_command : get_pipeline_commands(commands, false)
 
-              span.service = datadog_configuration[:service_name]
-              span.span_type = Contrib::Redis::Ext::TYPE
-              span.resource = pipelined_commands.join("\n")
-              span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, pipelined_commands.length
+                span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
 
-              Contrib::Redis::Tags.set_common_tags(redis_config, span, datadog_configuration[:command_args])
+                Contrib::Redis::Tags.set_common_tags(client, span, raw_command)
 
-              super
+                yield
+              end
             end
-          end
 
-          private
+            private
 
-          def get_command(commands, boolean)
-            if boolean
-              Contrib::Redis::Quantize.format_command_args(commands)
-            else
-              Contrib::Redis::Quantize.get_verb(commands)
+            # Quantizes a single Redis command
+            def get_command(command, command_args)
+              if command_args
+                Contrib::Redis::Quantize.format_command_args(command)
+              else
+                Contrib::Redis::Quantize.get_verb(command)
+              end
             end
-          end
 
-          def get_pipeline_commands(commands, boolean)
-            if boolean
-              commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
-            else
-              commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
+            # 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
+
+              list.empty? ? '(none)' : list.join("\n")
             end
           end
 
+          private
+
           def resolve(redis_config)
             custom = redis_config.custom[:datadog] || {}
 

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

@@ -13,22 +13,28 @@ module Datadog
           # @public_api
           class Settings < Contrib::Configuration::Settings
             option :enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
             end
 
             option :analytics_enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
             end
 
             option :analytics_sample_rate do |o|
-              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
-              o.lazy
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
             end
 
             option :service_name
-            option :error_handler, default: Tracing::SpanOperation::Events::DEFAULT_ON_ERROR
+            option :error_handler do |o|
+              o.type :proc
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+            end
           end
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Tracing
     module Contrib
@@ -5,13 +7,13 @@ module Datadog
         # Resque integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_RESQUE_ENABLED'.freeze
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RESQUE_ANALYTICS_ENABLED'.freeze
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RESQUE_ANALYTICS_SAMPLE_RATE'.freeze
-          SERVICE_NAME = 'resque'.freeze
-          SPAN_JOB = 'resque.job'.freeze
-          TAG_COMPONENT = 'resque'.freeze
-          TAG_OPERATION_JOB = 'job'.freeze
+          ENV_ENABLED = 'DD_TRACE_RESQUE_ENABLED'
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RESQUE_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RESQUE_ANALYTICS_SAMPLE_RATE'
+          SERVICE_NAME = 'resque'
+          SPAN_JOB = 'resque.job'
+          TAG_COMPONENT = 'resque'
+          TAG_OPERATION_JOB = 'job'
         end
       end
     end

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

@@ -12,21 +12,24 @@ module Datadog
           # @public_api
           class Settings < Contrib::Configuration::Settings
             option :enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
             end
 
             option :analytics_enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
             end
 
             option :analytics_sample_rate do |o|
-              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
-              o.lazy
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
             end
 
-            option :distributed_tracing, default: true
+            option :distributed_tracing, default: true, type: :bool
 
             option :service_name do |o|
               o.default do
@@ -35,10 +38,14 @@ module Datadog
                   Ext::DEFAULT_PEER_SERVICE_NAME
                 )
               end
-              o.lazy
             end
 
-            option :split_by_domain, default: false
+            option :peer_service do |o|
+              o.type :string, nilable: true
+              o.env Ext::ENV_PEER_SERVICE
+            end
+
+            option :split_by_domain, default: false, type: :bool
           end
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Tracing
     module Contrib
@@ -5,14 +7,19 @@ module Datadog
         # RestClient integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_REST_CLIENT_ENABLED'.freeze
-          ENV_SERVICE_NAME = 'DD_TRACE_REST_CLIENT_SERVICE_NAME'.freeze
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_REST_CLIENT_ANALYTICS_ENABLED'.freeze
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_REST_CLIENT_ANALYTICS_SAMPLE_RATE'.freeze
-          DEFAULT_PEER_SERVICE_NAME = 'rest_client'.freeze
-          SPAN_REQUEST = 'rest_client.request'.freeze
-          TAG_COMPONENT = 'rest_client'.freeze
-          TAG_OPERATION_REQUEST = 'request'.freeze
+          ENV_ENABLED = 'DD_TRACE_REST_CLIENT_ENABLED'
+          ENV_SERVICE_NAME = 'DD_TRACE_REST_CLIENT_SERVICE_NAME'
+          ENV_PEER_SERVICE = 'DD_TRACE_REST_CLIENT_PEER_SERVICE'
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_REST_CLIENT_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_REST_CLIENT_ANALYTICS_SAMPLE_RATE'
+          DEFAULT_PEER_SERVICE_NAME = 'rest_client'
+          SPAN_REQUEST = 'rest_client.request'
+          TAG_COMPONENT = 'rest_client'
+          TAG_OPERATION_REQUEST = 'request'
+          PEER_SERVICE_SOURCES = Array[
+            Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
+            Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
         end
       end
     end