ddtrace 1.12.1 → 1.23.2

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

@@ -24,35 +24,39 @@ module Datadog
             end
 
             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
 
+            # @!visibility private
             option :analytics_enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, nil) }
-              o.lazy
-              o.on_set do |value|
+              o.type :bool, nilable: true
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.after_set do |value|
                 # Update ActionPack analytics too
                 Datadog.configuration.tracing[:action_pack][:analytics_enabled] = value
               end
             end
 
             option :analytics_sample_rate do |o|
-              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
-              o.lazy
-              o.on_set do |value|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+              o.after_set do |value|
                 # Update ActionPack analytics too
                 Datadog.configuration.tracing[:action_pack][:analytics_sample_rate] = value
               end
             end
 
-            option :distributed_tracing, default: true
-
-            option :request_queuing, default: false
+            option :distributed_tracing, default: true, type: :bool
 
+            option :request_queuing do |o|
+              o.default false
+            end
             # DEV-2.0: Breaking changes for removal.
             option :exception_controller do |o|
-              o.on_set do |value|
+              o.after_set do |value|
                 if value
                   Datadog::Core.log_deprecation do
                     'The error controller is now automatically detected. '\
@@ -62,11 +66,12 @@ module Datadog
               end
             end
 
-            option :middleware, default: true
-            option :middleware_names, default: false
+            option :middleware, default: true, type: :bool
+            option :middleware_names, default: false, type: :bool
             option :template_base_path do |o|
+              o.type :string
               o.default 'views/'
-              o.on_set do |value|
+              o.after_set do |value|
                 # Update ActionView template base path too
                 Datadog.configuration.tracing[:action_view][:template_base_path] = value
               end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Tracing
     module Contrib
@@ -5,11 +7,12 @@ module Datadog
         # Rails integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          APP = 'rails'.freeze
-          ENV_ENABLED = 'DD_TRACE_RAILS_ENABLED'.freeze
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAILS_ANALYTICS_ENABLED'.freeze
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RAILS_ANALYTICS_SAMPLE_RATE'.freeze
-          ENV_DISABLE = 'DISABLE_DATADOG_RAILS'.freeze
+          APP = 'rails'
+          ENV_ENABLED = 'DD_TRACE_RAILS_ENABLED'
+          # @!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'
         end
       end
     end

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

@@ -7,17 +7,14 @@ module Datadog
         module LogInjection
           module_function
 
-          def add_as_tagged_logging_logger(app)
-            # we want to check if the current logger is a tagger logger instance
-            # log_tags defaults to nil so we have to set as an array if nothing exists yet
-            if (log_tags = app.config.log_tags).nil?
-              app.config.log_tags = [proc { Tracing.log_correlation }]
-            # if existing log_tags configuration exists, append to the end of the array
-            elsif log_tags.is_a?(Array)
-              app.config.log_tags << proc { Tracing.log_correlation }
-            end
+          # Use `app.config.log_tags` to inject propagation tags into the default Rails logger.
+          def configure_log_tags(app_config)
+            # When using SemanticLogger, app_config.log_tags could be a Hash and should not be modified here
+            return unless app_config.log_tags.nil? || app_config.log_tags.respond_to?(:<<)
+
+            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
-            # TODO: can we use Datadog.logger at this point?
             Datadog.logger.warn(
               "Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.class.name} #{e.message}"
             )

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,25 @@ 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
 
+            # @!visibility private
             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 +40,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,19 @@ 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'
+          # @!visibility private
+          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,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
 
+            # @!visibility private
             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 +43,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,27 @@ 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'
+          # @!visibility private
+          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,37 +18,17 @@ 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
 
             def command_args?
-              pinned = Datadog.configuration_for(redis_instance, :command_args)
+              pinned = Datadog.configuration_for(self, :command_args)
 
               return pinned unless pinned.nil?
 
@@ -55,26 +36,10 @@ module Datadog
             end
 
             def service_name
-              Datadog.configuration_for(redis_instance, :service_name) ||
+              Datadog.configuration_for(self, :service_name) ||
                 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/patcher.rb

@@ -10,38 +10,48 @@ module Datadog
         module Patcher
           include Contrib::Patcher
 
-          # Patch for redis instance
-          module InstancePatch
+          # Patch for redis instance (with redis < 5)
+          module DatadogPinPatch
             def self.included(base)
               base.prepend(InstanceMethods)
             end
 
             # Instance method patch for redis instance
             module InstanceMethods
-              # `options` could be frozen
-              def initialize(options = {})
-                super(options.merge(redis_instance: self))
+              def datadog_pin=(pin)
+                pin.onto(datadog_target)
+              end
+
+              def datadog_target
+                # For `redis-rb` 4.x
+                return _client if respond_to?(:_client)
+                # For `redis-rb` 3.x
+                return client if respond_to?(:client)
+
+                Datadog.logger.warn 'Fail to apply configuration on redis client instance with '  \
+                                                        '`Datadog.configure_onto(redis)`.'
+
+                # Null object instead of raising error
+                self
               end
             end
           end
 
-          # Patch for redis client
-          module ClientPatch
+          # Patch for redis instance (with redis >= 5)
+          module NotSupportedNoticePatch
             def self.included(base)
               base.prepend(InstanceMethods)
             end
 
-            # Instance method patch for redis client
+            # Instance method patch for redis instance
             module InstanceMethods
-              def initialize(options = {})
-                @redis_instance = options.delete(:redis_instance)
-
-                super(options)
+              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"\
+                  "  `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
-
-              private
-
-              attr_reader :redis_instance
             end
           end
 
@@ -62,12 +72,15 @@ module Datadog
               ::RedisClient.register(TraceMiddleware)
             end
 
-            if Integration.redis_compatible? && Integration.redis_version < Gem::Version.new('5.0.0')
-              require_relative 'instrumentation'
+            if Integration.redis_compatible?
+              if Integration.redis_version < Gem::Version.new('5.0.0')
+                require_relative 'instrumentation'
 
-              ::Redis.include(InstancePatch)
-              ::Redis::Client.include(ClientPatch)
-              ::Redis::Client.include(Instrumentation)
+                ::Redis.include(DatadogPinPatch)
+                ::Redis::Client.include(Instrumentation)
+              else # warn about non-supported configure_onto usage
+                ::Redis.include(NotSupportedNoticePatch)
+              end
             end
           end
         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