ddtrace 1.14.0 → 1.16.0

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

@@ -10,266 +10,175 @@ 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`.
+                # DEV: String#demodulize is available through ActiveSupport, and is
+                # DEV: used to remove the module ('*::') part of a constant name.
+                @store_name = self.class.name.demodulize.underscore
+              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/concurrent_ruby/context_composite_executor_service.rb

@@ -6,7 +6,7 @@ module Datadog
   module Tracing
     module Contrib
       module ConcurrentRuby
-        # wraps existing executor to carry over trace context
+        # Wraps existing executor to carry over trace context
         class ContextCompositeExecutorService
           include Concurrent::ExecutorService
 
@@ -16,20 +16,20 @@ module Datadog
             @composited_executor = composited_executor
           end
 
-          # post method runs the task within composited executor - in a different thread
+          # post method runs the task within composited executor - in a different thread. The original arguments are
+          # captured to be propagated to the composited executor post method
           def post(*args, &task)
-            tracer = Tracing.send(:tracer)
-            parent_context = tracer.provider.context
-
-            @composited_executor.post(*args) do
-              begin
-                original_context = tracer.provider.context
-                tracer.provider.context = parent_context
-                yield
-              ensure
-                # Restore context in case the current thread gets reused
-                tracer.provider.context = original_context
-              end
+            digest = Tracing.active_trace.to_digest
+            executor = @composited_executor.is_a?(Symbol) ? Concurrent.executor(@composited_executor) : @composited_executor
+
+            # Pass the original arguments to the composited executor, which
+            # pushes them (possibly transformed) as block args
+            executor.post(*args) do |*block_args|
+              Tracing.continue_trace!(digest)
+
+              # Pass the executor-provided block args as they should have been
+              # originally passed without composition, see ChainPromise#on_resolvable
+              yield(*block_args)
             end
           end
 

data/lib/datadog/tracing/contrib/concurrent_ruby/future_patch.rb

@@ -8,17 +8,10 @@ module Datadog
       module ConcurrentRuby
         # This patches the Future - to wrap executor service using ContextCompositeExecutorService
         module FuturePatch
-          def self.included(base)
-            base.class_eval do
-              alias_method :ns_initialize_without_datadog, :ns_initialize
-              remove_method(:ns_initialize)
+          def ns_initialize(value, opts)
+            super(value, opts)
 
-              def ns_initialize(value, opts)
-                ns_initialize_without_datadog(value, opts)
-
-                @executor = ContextCompositeExecutorService.new(@executor)
-              end
-            end
+            @executor = ContextCompositeExecutorService.new(@executor)
           end
         end
       end

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

@@ -20,7 +20,8 @@ module Datadog
           end
 
           def self.loaded?
-            !defined?(::Concurrent::Future).nil?
+            # Concurrent::Future is deprecated in favour of Concurrent::Promises::Future
+            !defined?(::Concurrent::Promises::Future).nil? || !defined?(::Concurrent::Future).nil?
           end
 
           def self.compatible?

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

@@ -19,11 +19,18 @@ module Datadog
           def patch
             require_relative 'future_patch'
             patch_future
+            require_relative 'promises_future_patch'
+            patch_promises_future
           end
 
           # Propagate tracing context in Concurrent::Future
           def patch_future
-            ::Concurrent::Future.include(FuturePatch)
+            ::Concurrent::Future.prepend(FuturePatch) if defined?(::Concurrent::Future)
+          end
+
+          # Propagate tracing context in Concurrent::Promises::Future
+          def patch_promises_future
+            ::Concurrent::Promises.singleton_class.prepend(PromisesFuturePatch) if defined?(::Concurrent::Promises::Future)
           end
         end
       end

data/lib/datadog/tracing/contrib/concurrent_ruby/promises_future_patch.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'context_composite_executor_service'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ConcurrentRuby
+        # This patches the Future - to wrap executor service using ContextCompositeExecutorService
+        module PromisesFuturePatch
+          def future_on(default_executor, *args, &task)
+            unless default_executor.is_a?(ContextCompositeExecutorService)
+              default_executor = ContextCompositeExecutorService.new(default_executor)
+            end
+
+            super(default_executor, *args, &task)
+          end
+        end
+      end
+    end
+  end
+end

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?