ddtrace 1.12.1 → 1.18.0

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

@@ -10,271 +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)
-
-              if Contrib::SpanAttributeSchema.default_span_attribute_schema?
-                # Tag as an external peer service
-                span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, service)
-              end
-
-              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/active_support/configuration/settings.rb

@@ -12,18 +12,21 @@ 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 :cache_service do |o|
@@ -33,7 +36,6 @@ module Datadog
                   Ext::SERVICE_CACHE
                 )
               end
-              o.lazy
             end
           end
         end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Tracing
     module Contrib
@@ -5,23 +7,23 @@ module Datadog
         # ActiveSupport integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_ACTIVE_SUPPORT_ENABLED'.freeze
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTIVE_SUPPORT_ANALYTICS_ENABLED'.freeze
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTIVE_SUPPORT_ANALYTICS_SAMPLE_RATE'.freeze
+          ENV_ENABLED = 'DD_TRACE_ACTIVE_SUPPORT_ENABLED'
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTIVE_SUPPORT_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTIVE_SUPPORT_ANALYTICS_SAMPLE_RATE'
           QUANTIZE_CACHE_MAX_KEY_SIZE = 300
-          RESOURCE_CACHE_DELETE = 'DELETE'.freeze
-          RESOURCE_CACHE_GET = 'GET'.freeze
-          RESOURCE_CACHE_MGET = 'MGET'.freeze
-          RESOURCE_CACHE_SET = 'SET'.freeze
-          RESOURCE_CACHE_MSET = 'MSET'.freeze
-          SERVICE_CACHE = 'active_support-cache'.freeze
-          SPAN_CACHE = 'rails.cache'.freeze
-          SPAN_TYPE_CACHE = 'cache'.freeze
-          TAG_CACHE_BACKEND = 'rails.cache.backend'.freeze
-          TAG_CACHE_KEY = 'rails.cache.key'.freeze
-          TAG_CACHE_KEY_MULTI = 'rails.cache.keys'.freeze
-          TAG_COMPONENT = 'active_support'.freeze
-          TAG_OPERATION_CACHE = 'cache'.freeze
+          RESOURCE_CACHE_DELETE = 'DELETE'
+          RESOURCE_CACHE_GET = 'GET'
+          RESOURCE_CACHE_MGET = 'MGET'
+          RESOURCE_CACHE_SET = 'SET'
+          RESOURCE_CACHE_MSET = 'MSET'
+          SERVICE_CACHE = 'active_support-cache'
+          SPAN_CACHE = 'rails.cache'
+          SPAN_TYPE_CACHE = 'cache'
+          TAG_CACHE_BACKEND = 'rails.cache.backend'
+          TAG_CACHE_KEY = 'rails.cache.key'
+          TAG_CACHE_KEY_MULTI = 'rails.cache.keys'
+          TAG_COMPONENT = 'active_support'
+          TAG_OPERATION_CACHE = 'cache'
         end
       end
     end

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

@@ -13,18 +13,21 @@ 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 do |o|
@@ -34,7 +37,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/aws/ext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Tracing
     module Contrib
@@ -5,30 +7,41 @@ module Datadog
         # AWS integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_AWS_ENABLED'.freeze
-          ENV_SERVICE_NAME = 'DD_TRACE_AWS_SERVICE_NAME'.freeze
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_AWS_ANALYTICS_ENABLED'.freeze
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_AWS_ANALYTICS_SAMPLE_RATE'.freeze
-          DEFAULT_PEER_SERVICE_NAME = 'aws'.freeze
-          SPAN_COMMAND = 'aws.command'.freeze
-          TAG_AGENT = 'aws.agent'.freeze
-          TAG_COMPONENT = 'aws'.freeze
-          TAG_DEFAULT_AGENT = 'aws-sdk-ruby'.freeze
-          TAG_HOST = 'host'.freeze
-          TAG_OPERATION = 'aws.operation'.freeze
-          TAG_OPERATION_COMMAND = 'command'.freeze
-          TAG_PATH = 'path'.freeze
-          TAG_AWS_REGION = 'aws.region'.freeze
-          TAG_REGION = 'region'.freeze
-          TAG_AWS_SERVICE = 'aws_service'.freeze
-          TAG_AWS_ACCOUNT = 'aws_account'.freeze
-          TAG_QUEUE_NAME = 'queuename'.freeze
-          TAG_TOPIC_NAME = 'topicname'.freeze
-          TAG_TABLE_NAME = 'tablename'.freeze
-          TAG_STREAM_NAME = 'streamname'.freeze
-          TAG_RULE_NAME = 'rulename'.freeze
-          TAG_STATE_MACHINE_NAME = 'statemachinename'.freeze
-          TAG_BUCKET_NAME = 'bucketname'.freeze
+          ENV_ENABLED = 'DD_TRACE_AWS_ENABLED'
+          ENV_SERVICE_NAME = 'DD_TRACE_AWS_SERVICE_NAME'
+          ENV_PEER_SERVICE = 'DD_TRACE_AWS_PEER_SERVICE'
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_AWS_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_AWS_ANALYTICS_SAMPLE_RATE'
+          DEFAULT_PEER_SERVICE_NAME = 'aws'
+          SPAN_COMMAND = 'aws.command'
+          TAG_AGENT = 'aws.agent'
+          TAG_COMPONENT = 'aws'
+          TAG_DEFAULT_AGENT = 'aws-sdk-ruby'
+          TAG_HOST = 'host'
+          TAG_OPERATION = 'aws.operation'
+          TAG_OPERATION_COMMAND = 'command'
+          TAG_PATH = 'path'
+          TAG_AWS_REGION = 'aws.region'
+          TAG_REGION = 'region'
+          TAG_AWS_SERVICE = 'aws_service'
+          TAG_AWS_ACCOUNT = 'aws_account'
+          TAG_QUEUE_NAME = 'queuename'
+          TAG_TOPIC_NAME = 'topicname'
+          TAG_TABLE_NAME = 'tablename'
+          TAG_STREAM_NAME = 'streamname'
+          TAG_RULE_NAME = 'rulename'
+          TAG_STATE_MACHINE_NAME = 'statemachinename'
+          TAG_BUCKET_NAME = 'bucketname'
+          PEER_SERVICE_SOURCES = Array[TAG_QUEUE_NAME,
+            TAG_TOPIC_NAME,
+            TAG_STREAM_NAME,
+            TAG_TABLE_NAME,
+            TAG_BUCKET_NAME,
+            TAG_RULE_NAME,
+            TAG_STATE_MACHINE_NAME,
+            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/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
@@ -40,16 +41,23 @@ module Datadog
               handler.add_tags(span, params)
             end
 
+            if configuration[:peer_service]
+              span.set_tag(
+                Tracing::Metadata::Ext::TAG_PEER_SERVICE,
+                configuration[:peer_service]
+              )
+            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)
             span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_COMMAND)
 
-            # Tag as an external peer service
-            if Contrib::SpanAttributeSchema.default_span_attribute_schema?
-              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, span.service)
-            end
-
             span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, context.safely(:host))
 
             # Set analytics sample rate
@@ -66,7 +74,10 @@ module Datadog
             span.set_tag(Ext::TAG_HOST, context.safely(:host))
             span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, context.safely(:http_method))
             span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, context.safely(:status_code))
+
+            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/configuration/settings.rb

@@ -12,8 +12,9 @@ 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
           end
         end