ddtrace 1.14.0 → 1.15.0

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

@@ -1,4 +1,5 @@
 require_relative '../../tracing/configuration/ext'
+require_relative '../../core/environment/variable_helpers'
 require_relative 'http'
 
 module Datadog
@@ -64,7 +65,7 @@ module Datadog
                       Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER,
                     ]
                   )
-                  o.on_set do |styles|
+                  o.after_set do |styles|
                     # Modernize B3 options
                     # DEV-2.0: Can be removed with the removal of deprecated B3 constants.
                     styles.map! do |style|
@@ -93,7 +94,7 @@ module Datadog
                   o.env Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_INJECT
                   # DEV-2.0: Change default value to `tracecontext, Datadog`.
                   o.default [Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG]
-                  o.on_set do |styles|
+                  o.after_set do |styles|
                     # Modernize B3 options
                     # DEV-2.0: Can be removed with the removal of deprecated B3 constants.
                     styles.map! do |style|
@@ -121,7 +122,7 @@ module Datadog
                   o.type :array
                   o.env Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE
                   o.default []
-                  o.on_set do |styles|
+                  o.after_set do |styles|
                     next if styles.empty?
 
                     # Modernize B3 options
@@ -371,6 +372,12 @@ module Datadog
                   o.env Tracing::Configuration::Ext::Test::ENV_MODE_ENABLED
                 end
 
+                # Use async writer in test mode
+                option :async do |o|
+                  o.type :bool
+                  o.default false
+                end
+
                 option :trace_flush
 
                 option :writer_options do |o|
@@ -382,8 +389,8 @@ module Datadog
               # @see file:docs/GettingStarted.md#configuring-the-transport-layer Configuring the transport layer
               #
               # A {Proc} that configures a custom tracer transport.
-              # @yield Receives a {Datadog::Transport::HTTP} that can be modified with custom adapters and settings.
-              # @yieldparam [Datadog::Transport::HTTP] t transport to be configured.
+              # @yield Receives a {Datadog::Tracing::Transport::HTTP} that can be modified with custom adapters and settings.
+              # @yieldparam [Datadog::Tracing::Transport::HTTP] t transport to be configured.
               # @default `nil`
               # @return [Proc,nil]
               option :transport_options do |o|
@@ -425,7 +432,7 @@ module Datadog
                 option :enabled do |o|
                   o.type :bool
                   o.default do
-                    disabled = env_to_bool(Tracing::Configuration::Ext::ClientIp::ENV_DISABLED)
+                    disabled = Core::Environment::VariableHelpers.env_to_bool(Tracing::Configuration::Ext::ClientIp::ENV_DISABLED)
 
                     enabled = if disabled.nil?
                                 false
@@ -438,7 +445,7 @@ module Datadog
                               end
 
                     # ENABLED env var takes precedence over deprecated DISABLED
-                    env_to_bool(Tracing::Configuration::Ext::ClientIp::ENV_ENABLED, enabled)
+                    Core::Environment::VariableHelpers.env_to_bool(Tracing::Configuration::Ext::ClientIp::ENV_ENABLED, enabled)
                   end
                 end
 

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

@@ -30,7 +30,7 @@ module Datadog
 
             # 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. '\

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

@@ -33,7 +33,7 @@ module Datadog
             option :service_name
             option :error_handler do |o|
               o.type :proc
-              o.experimental_default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
             end
           end
         end

data/lib/datadog/tracing/contrib/active_record/events/sql.rb

@@ -45,6 +45,10 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_SQL)
 
+              if service_name != Datadog.configuration.service
+                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
+              end
+
               # Set analytics sample rate
               if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
                 Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])

data/lib/datadog/tracing/contrib/active_support/cache/instrumentation.rb

@@ -10,266 +10,173 @@ module Datadog
       module ActiveSupport
         module Cache
           # Defines instrumentation for ActiveSupport caching
-          # rubocop:disable Lint/RescueException
           module Instrumentation
             module_function
 
-            def start_trace_cache(payload)
-              return unless enabled?
-
-              # In most of the cases Rails ``fetch()`` and ``read()`` calls are nested.
-              # This check ensures that two reads are not nested since they don't provide
-              # interesting details.
-              # NOTE: the ``finish_trace_cache()`` is fired but it already has a safe-guard
-              # to avoid any kind of issue.
-              current_span = Tracing.active_span
-              return if current_span.try(:name) == Ext::SPAN_CACHE &&
-                (
-                  payload[:action] == Ext::RESOURCE_CACHE_GET &&
-                  current_span.try(:resource) == Ext::RESOURCE_CACHE_GET ||
-                  payload[:action] == Ext::RESOURCE_CACHE_MGET &&
-                  current_span.try(:resource) == Ext::RESOURCE_CACHE_MGET
-                )
-
-              tracing_context = payload.fetch(:tracing_context)
+            # @param action [String] type of cache operation. Will be set as the span resource.
+            # @param key [Object] redis cache key. Used for actions with a single key locator.
+            # @param multi_key [Array<Object>] list of redis cache keys. Used for actions with a multiple key locators.
+            def trace(action, store, key: nil, multi_key: nil)
+              return yield unless enabled?
 
               # create a new ``Span`` and add it to the tracing context
-              service = Datadog.configuration.tracing[:active_support][:cache_service]
-              type = Ext::SPAN_TYPE_CACHE
-              span = Tracing.trace(Ext::SPAN_CACHE, service: service, span_type: type)
-              span.resource = payload.fetch(:action)
-
-              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
-              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_CACHE)
-
-              tracing_context[:dd_cache_span] = span
-            rescue StandardError => e
-              Datadog.logger.debug(e.message)
-            end
-
-            def finish_trace_cache(payload)
-              return unless enabled?
-
-              # retrieve the tracing context and continue the trace
-              tracing_context = payload.fetch(:tracing_context)
-              span = tracing_context[:dd_cache_span]
-              return unless span && !span.finished?
-
-              begin
-                # discard parameters from the cache_store configuration
-                if defined?(::Rails)
-                  store, = *Array.wrap(::Rails.configuration.cache_store).flatten
-                  span.set_tag(Ext::TAG_CACHE_BACKEND, store)
+              Tracing.trace(
+                Ext::SPAN_CACHE,
+                span_type: Ext::SPAN_TYPE_CACHE,
+                service: Datadog.configuration.tracing[:active_support][:cache_service],
+                resource: action
+              ) do |span|
+                span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_CACHE)
+
+                if span.service != Datadog.configuration.service
+                  span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
                 end
 
-                normalized_key = ::ActiveSupport::Cache.expand_cache_key(payload.fetch(:key))
-                cache_key = Core::Utils.truncate(normalized_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
-                span.set_tag(Ext::TAG_CACHE_KEY, cache_key)
+                span.set_tag(Ext::TAG_CACHE_BACKEND, store) if store
+                set_cache_key(span, key, multi_key)
 
-                span.set_error(payload[:exception]) if payload[:exception]
-              ensure
-                span.finish
+                yield
               end
-            rescue StandardError => e
-              Datadog.logger.debug(e.message)
             end
 
-            def finish_trace_cache_multi(payload)
-              return unless enabled?
-
-              # retrieve the tracing context and continue the trace
-              tracing_context = payload.fetch(:tracing_context)
-              span = tracing_context[:dd_cache_span]
-              return unless span && !span.finished?
+            # In most of the cases, `#fetch()` and `#read()` calls are nested.
+            # Instrument both does not add any value.
+            # This method checks if these two operations are nested.
+            def nested_read?
+              current_span = Tracing.active_span
+              current_span && current_span.name == Ext::SPAN_CACHE && current_span.resource == Ext::RESOURCE_CACHE_GET
+            end
 
-              begin
-                # discard parameters from the cache_store configuration
-                if defined?(::Rails)
-                  store, = *Array.wrap(::Rails.configuration.cache_store).flatten
-                  span.set_tag(Ext::TAG_CACHE_BACKEND, store)
-                end
-                normalized_keys = payload.fetch(:keys, []).map do |key|
-                  ::ActiveSupport::Cache.expand_cache_key(key)
-                end
-                cache_keys = Core::Utils.truncate(normalized_keys, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
-                span.set_tag(Ext::TAG_CACHE_KEY_MULTI, cache_keys)
+            # (see #nested_read?)
+            def nested_multiread?
+              current_span = Tracing.active_span
+              current_span && current_span.name == Ext::SPAN_CACHE && current_span.resource == Ext::RESOURCE_CACHE_MGET
+            end
 
-                span.set_error(payload[:exception]) if payload[:exception]
-              ensure
-                span.finish
+            def set_cache_key(span, single_key, multi_key)
+              if multi_key
+                resolved_key = multi_key.map { |key| ::ActiveSupport::Cache.expand_cache_key(key) }
+                cache_key = Core::Utils.truncate(resolved_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
+                span.set_tag(Ext::TAG_CACHE_KEY_MULTI, cache_key)
+              else
+                resolved_key = ::ActiveSupport::Cache.expand_cache_key(single_key)
+                cache_key = Core::Utils.truncate(resolved_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
+                span.set_tag(Ext::TAG_CACHE_KEY, cache_key)
               end
-            rescue StandardError => e
-              Datadog.logger.debug(e.message)
             end
 
             def enabled?
               Tracing.enabled? && Datadog.configuration.tracing[:active_support][:enabled]
             end
 
+            # Instance methods injected into the cache client
+            module InstanceMethods
+              private
+
+              # The name of the store is never saved.
+              # ActiveSupport looks up stores by converting a symbol into a 'require' path,
+              # then "camelizing" it for a `const_get` call:
+              # ```
+              # require "active_support/cache/#{store}"
+              # ActiveSupport::Cache.const_get(store.to_s.camelize)
+              # ```
+              # @see https://github.com/rails/rails/blob/261975dbef77731d2c76f907f1076c5132ebc0e4/activesupport/lib/active_support/cache.rb#L139-L149
+              #
+              # As `self` is the store object, we can reverse engineer
+              # the original symbol by converting the class name to snake case:
+              # e.g. ActiveSupport::Cache::RedisStore -> active_support/cache/redis_store
+              # In this case, `redis_store` is the store name.
+              #
+              # Because there's no API retrieve only the class name
+              # (only `RedisStore`, and not `ActiveSupport::Cache::RedisStore`)
+              # the easiest way to retrieve the store symbol is to convert the fully qualified
+              # name using the Rails-provided method `#underscore`, which is the reverse of `#camelize`,
+              # then extracting the last part of it.
+              #
+              # Also, this method caches the store name, given this value will be retrieve
+              # multiple times and involves string manipulation.
+              def dd_store_name
+                return @store_name if defined?(@store_name)
+
+                # DEV: String#underscore is available through ActiveSupport, and is
+                # DEV: the exact reverse operation to `#camelize`.
+                @store_name = self.class.name.underscore.match(%r{active_support/cache/(.*)})[1]
+              end
+            end
+
             # Defines instrumentation for ActiveSupport cache reading
             module Read
+              include InstanceMethods
+
               def read(*args, &block)
-                payload = {
-                  action: Ext::RESOURCE_CACHE_GET,
-                  key: args[0],
-                  tracing_context: {}
-                }
-
-                begin
-                  # process and catch cache exceptions
-                  Instrumentation.start_trace_cache(payload)
-                  super
-                rescue Exception => e
-                  payload[:exception] = [e.class.name, e.message]
-                  payload[:exception_object] = e
-                  raise e
-                end
-              ensure
-                Instrumentation.finish_trace_cache(payload)
+                return super if Instrumentation.nested_read?
+
+                Instrumentation.trace(Ext::RESOURCE_CACHE_GET, dd_store_name, key: args[0]) { super }
               end
             end
 
             # Defines instrumentation for ActiveSupport cache reading of multiple keys
             module ReadMulti
+              include InstanceMethods
+
               def read_multi(*keys, &block)
-                payload = {
-                  action: Ext::RESOURCE_CACHE_MGET,
-                  keys: keys,
-                  tracing_context: {}
-                }
-
-                begin
-                  # process and catch cache exceptions
-                  Instrumentation.start_trace_cache(payload)
-                  super
-                rescue Exception => e
-                  payload[:exception] = [e.class.name, e.message]
-                  payload[:exception_object] = e
-                  raise e
-                end
-              ensure
-                Instrumentation.finish_trace_cache_multi(payload)
+                return super if Instrumentation.nested_multiread?
+
+                Instrumentation.trace(Ext::RESOURCE_CACHE_MGET, dd_store_name, multi_key: keys) { super }
               end
             end
 
             # Defines instrumentation for ActiveSupport cache fetching
             module Fetch
+              include InstanceMethods
+
               def fetch(*args, &block)
-                payload = {
-                  action: Ext::RESOURCE_CACHE_GET,
-                  key: args[0],
-                  tracing_context: {}
-                }
-
-                begin
-                  # process and catch cache exceptions
-                  Instrumentation.start_trace_cache(payload)
-                  super
-                rescue Exception => e
-                  payload[:exception] = [e.class.name, e.message]
-                  payload[:exception_object] = e
-                  raise e
-                end
-              ensure
-                Instrumentation.finish_trace_cache(payload)
+                return super if Instrumentation.nested_read?
+
+                Instrumentation.trace(Ext::RESOURCE_CACHE_GET, dd_store_name, key: args[0]) { super }
               end
             end
 
             # Defines instrumentation for ActiveSupport cache fetching of multiple keys
             module FetchMulti
+              include InstanceMethods
+
               def fetch_multi(*args, &block)
-                # extract options hash
+                return super if Instrumentation.nested_multiread?
+
                 keys = args[-1].instance_of?(Hash) ? args[0..-2] : args
-                payload = {
-                  action: Ext::RESOURCE_CACHE_MGET,
-                  keys: keys,
-                  tracing_context: {}
-                }
-
-                begin
-                  # process and catch cache exceptions
-                  Instrumentation.start_trace_cache(payload)
-                  super
-                rescue Exception => e
-                  payload[:exception] = [e.class.name, e.message]
-                  payload[:exception_object] = e
-                  raise e
-                end
-              ensure
-                Instrumentation.finish_trace_cache_multi(payload)
+                Instrumentation.trace(Ext::RESOURCE_CACHE_MGET, dd_store_name, multi_key: keys) { super }
               end
             end
 
             # Defines instrumentation for ActiveSupport cache writing
             module Write
+              include InstanceMethods
+
               def write(*args, &block)
-                payload = {
-                  action: Ext::RESOURCE_CACHE_SET,
-                  key: args[0],
-                  tracing_context: {}
-                }
-
-                begin
-                  # process and catch cache exceptions
-                  Instrumentation.start_trace_cache(payload)
-                  super
-                rescue Exception => e
-                  payload[:exception] = [e.class.name, e.message]
-                  payload[:exception_object] = e
-                  raise e
-                end
-              ensure
-                Instrumentation.finish_trace_cache(payload)
+                Instrumentation.trace(Ext::RESOURCE_CACHE_SET, dd_store_name, key: args[0]) { super }
               end
             end
 
             # Defines instrumentation for ActiveSupport cache writing of multiple keys
             module WriteMulti
+              include InstanceMethods
+
               def write_multi(hash, options = nil)
-                payload = {
-                  action: Ext::RESOURCE_CACHE_MSET,
-                  keys: hash.keys,
-                  tracing_context: {}
-                }
-
-                begin
-                  # process and catch cache exceptions
-                  Instrumentation.start_trace_cache(payload)
-                  super
-                rescue Exception => e
-                  payload[:exception] = [e.class.name, e.message]
-                  payload[:exception_object] = e
-                  raise e
-                end
-              ensure
-                Instrumentation.finish_trace_cache_multi(payload)
+                Instrumentation.trace(Ext::RESOURCE_CACHE_MSET, dd_store_name, multi_key: hash.keys) { super }
               end
             end
 
             # Defines instrumentation for ActiveSupport cache deleting
             module Delete
+              include InstanceMethods
+
               def delete(*args, &block)
-                payload = {
-                  action: Ext::RESOURCE_CACHE_DELETE,
-                  key: args[0],
-                  tracing_context: {}
-                }
-
-                begin
-                  # process and catch cache exceptions
-                  Instrumentation.start_trace_cache(payload)
-                  super
-                rescue Exception => e
-                  payload[:exception] = [e.class.name, e.message]
-                  payload[:exception_object] = e
-                  raise e
-                end
-              ensure
-                Instrumentation.finish_trace_cache(payload)
+                Instrumentation.trace(Ext::RESOURCE_CACHE_DELETE, dd_store_name, key: args[0]) { super }
               end
             end
           end
-          # rubocop:enable Lint/RescueException
         end
       end
     end

data/lib/datadog/tracing/contrib/active_support/cache/patcher.rb

@@ -28,6 +28,9 @@ module Datadog
               patch_cache_store_delete
             end
 
+            # This method is overwritten by
+            # `datadog/tracing/contrib/active_support/cache/redis.rb`
+            # with more complex behavior.
             def cache_store_class(meth)
               ::ActiveSupport::Cache::Store
             end

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

@@ -28,6 +28,7 @@ module Datadog
 
           private
 
+          # rubocop:disable Metrics/AbcSize
           def annotate!(span, context)
             span.service = configuration[:service_name]
             span.span_type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
@@ -47,6 +48,11 @@ 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)
@@ -71,6 +77,7 @@ module Datadog
 
             Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
           end
+          # rubocop:enable Metrics/AbcSize
 
           def configuration
             Datadog.configuration.tracing[:aws]

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

@@ -18,7 +18,7 @@ module Datadog
           option :service_name
 
           def configure(options = {})
-            self.class.options.dependency_order.each do |name|
+            self.class.options.each do |name, _value|
               self[name] = options[name] if options.key?(name)
             end
 

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

@@ -42,6 +42,12 @@ module Datadog
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE
             end
+
+            option :command_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_COMMAND_ENABLED
+              o.default false
+            end
           end
         end
       end

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

@@ -7,9 +7,16 @@ module Datadog
         # Dalli integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
+          # DEV: Even though this is the dalli integration, all spans are named `memcached.*`.
+          # DEV: This happens because such spans have special treatment in backend, with memcached-specific handling.
+          # DEV: If add support for the `memcached` gem (not popular as of 2023), we'll have issues with span naming
+          # DEV: conflicts.
           ENV_ENABLED = 'DD_TRACE_DALLI_ENABLED'
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_DALLI_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_DALLI_ANALYTICS_SAMPLE_RATE'
+          # DEV: This is named `*_MEMCACHED_*` because the spans it refer to are `memcached.*` and this variable
+          # DEV: is a global flag that affects all memcached spans generated by any Datadog product.
+          ENV_COMMAND_ENABLED = 'DD_TRACE_MEMCACHED_COMMAND_ENABLED'
           ENV_SERVICE_NAME = 'DD_TRACE_DALLI_SERVICE_NAME'
           ENV_PEER_SERVICE = 'DD_TRACE_DALLI_PEER_SERVICE'
 

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

@@ -29,6 +29,11 @@ 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)
@@ -45,8 +50,10 @@ module Datadog
 
                 span.set_tag(Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM)
 
-                cmd = Quantize.format_command(op, args)
-                span.set_tag(Ext::TAG_COMMAND, cmd)
+                if datadog_configuration[:command_enabled]
+                  cmd = Quantize.format_command(op, args)
+                  span.set_tag(Ext::TAG_COMMAND, cmd)
+                end
 
                 Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
                 super

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

@@ -34,7 +34,7 @@ module Datadog
             option :client_service_name
             option :error_handler do |o|
               o.type :proc
-              o.experimental_default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
             end
           end
         end

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

@@ -77,6 +77,11 @@ 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.span_type = Datadog::Tracing::Contrib::Elasticsearch::Ext::SPAN_TYPE_QUERY
 
                   span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)

data/lib/datadog/tracing/contrib/ethon/easy_patch.rb

@@ -136,6 +136,11 @@ 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
+
               # Set analytics sample rate
               Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 

data/lib/datadog/tracing/contrib/ethon/multi_patch.rb

@@ -69,6 +69,14 @@ module Datadog
 
               @datadog_multi_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
 
+              # Tag original global service name if not used
+              if @datadog_multi_span.service != Datadog.configuration.service
+                @datadog_multi_span.set_tag(
+                  Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE,
+                  Datadog.configuration.service
+                )
+              end
+
               # Set analytics sample rate
               Contrib::Analytics.set_sample_rate(@datadog_multi_span, analytics_sample_rate) if analytics_enabled?
 

data/lib/datadog/tracing/contrib/excon/middleware.rb

@@ -121,6 +121,11 @@ 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)

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

@@ -45,6 +45,9 @@ module Datadog
 
           # Value of tag from which peer.service value was remapped from
           TAG_PEER_SERVICE_REMAP = '_dd.peer.service.remapped_from'
+
+          # Set equal to the global service when contrib span.service is overriden
+          TAG_BASE_SERVICE = '_dd.base_service'
         end
       end
     end