datadog 2.33.0 → 2.34.0

data/lib/datadog/symbol_database/extractor.rb

@@ -9,6 +9,10 @@ module Datadog
   module SymbolDatabase
     # Extracts symbol metadata from loaded Ruby modules and classes via introspection.
     #
+    # Instance created by Component with injected dependencies (logger, settings).
+    # All methods are instance methods accessing @logger, @settings directly —
+    # no parameter threading needed.
+    #
     # Uses Ruby's reflection APIs (Module#constants, Class#instance_methods, Method#parameters)
     # to build hierarchical Scope structures representing code organization.
     # Filters to user code only (excludes gems, stdlib, test files).
@@ -80,6 +84,11 @@ module Datadog
       MODULE_SINGLETON_CLASS_PRED = Module.instance_method(:singleton_class?)
       private_constant :MODULE_SINGLETON_CLASS_PRED
 
+      # Cached UnboundMethod for Module#name — avoids resolving it on every
+      # safe_mod_name call. Some classes override .name (e.g. Faker::Travel::Airport),
+      # so we bind the original Module#name to get the real module name safely.
+      MODULE_NAME = Module.instance_method(:name)
+
       # @param logger [Logger] Logger instance (SymbolDatabase::Logger facade or compatible)
       # @param settings [Configuration::Settings] Tracer settings
       def initialize(logger:, settings:)
@@ -150,7 +159,7 @@ module Datadog
       # @param mod [Module] The module
       # @return [String, nil] Module name or nil
       def safe_mod_name(mod)
-        Module.instance_method(:name).bind(mod).call
+        MODULE_NAME.bind(mod).call
       rescue => e
         @logger.debug { "symdb: safe_mod_name failed: #{e.class}: #{e.message}" }
         nil
@@ -605,10 +614,26 @@ module Datadog
 
       # ── extract_all helpers ──────────────────────────────────────────────
 
+      # Sleep between chunks of modules processed in collect_extractable_modules so
+      # request-handling threads have guaranteed CPU time while extraction is in
+      # flight. Unlike Thread.pass (which only offers the GVL among runnable
+      # threads and leaves the extractor immediately re-runnable), sleep removes
+      # the extractor thread from the runnable set for a fixed duration, capping
+      # its CPU share at sleep_work_ratio regardless of GVL scheduling.
+      #
+      # The cadence is measured in modules that pass the singleton-class fast-path
+      # skip — singleton classes are discarded in microseconds and counting them
+      # would add wall-clock delay disproportionate to the work being done (e.g.
+      # on heavily monkey-patched processes that retain large singleton chains).
+      SLEEP_EVERY_N_MODULES = 100
+      SLEEP_SECONDS = 0.001
+      private_constant :SLEEP_EVERY_N_MODULES, :SLEEP_SECONDS
+
       # Pass 1: Collect all extractable modules with methods grouped by source file.
       # @return [Hash] { mod_name => { mod:, methods_by_file: { path => [{name:, method:, type:}] } } }
       def collect_extractable_modules
         entries = {}
+        seen = 0
 
         ObjectSpace.each_object(Module) do |mod|
           # Singleton classes (per-object metaclasses) are never user-code classes.
@@ -620,6 +645,9 @@ module Datadog
           # processes. Ruby 2.7+ optimized this path; the skip is a no-op there.
           next if MODULE_SINGLETON_CLASS_PRED.bind(mod).call
 
+          seen += 1
+          sleep SLEEP_SECONDS if (seen % SLEEP_EVERY_N_MODULES).zero?
+
           mod_name = safe_mod_name(mod)
           next unless mod_name
           next unless user_code_module?(mod)

data/lib/datadog/symbol_database/remote.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Datadog
+  module SymbolDatabase
+    # Provides remote configuration integration for symbol database.
+    #
+    # Responsibilities:
+    # - Registers with Core::Remote as a receiver for LIVE_DEBUGGING_SYMBOL_DB product
+    # - Processes remote config changes (insert/update/delete)
+    # - Calls Component.start_upload when upload_symbols: true
+    # - Calls Component.stop_upload when config deleted or upload_symbols: false
+    #
+    # Flow:
+    # 1. Remote config system calls receiver with repository and changes
+    # 2. For each change, process_change called
+    # 3. parse_config extracts upload_symbols flag
+    # 4. enable_upload or disable_upload called on component
+    #
+    # Created by: Symbol database initialization
+    # Accessed by: Core::Remote system when configurations change
+    # Requires: Component must exist (accessed via Datadog.send(:components).symbol_database)
+    #
+    # @api private
+    module Remote
+      PRODUCT = 'LIVE_DEBUGGING_SYMBOL_DB'
+
+      class << self
+        # Declare products this receiver handles.
+        # @return [Array<String>] Product names
+        def products
+          [PRODUCT]
+        end
+
+        # Declare capabilities for this receiver.
+        # @return [Array] Capabilities (none for symbol database)
+        def capabilities
+          []
+        end
+
+        # Create receivers for remote configuration.
+        # @return [Array<Receiver>] Array of receivers
+        def receivers(_telemetry)
+          receiver do |repository, changes|
+            telemetry = lookup_telemetry
+            component = begin
+              Datadog.send(:components, allow_initialization: false)&.symbol_database
+            rescue => e
+              Datadog.logger.debug { "symdb: failed to look up component in RC receiver: #{e.class}: #{e.message}" }
+              telemetry&.report(e, description: 'symdb: failed to look up component in RC receiver')
+              nil
+            end
+
+            if component
+              changes.each do |change|
+                process_change(component, change, telemetry)
+              end
+            end
+          end
+        end
+
+        # Create a single receiver for the product.
+        # @param products [Array<String>] Product names to match
+        # @return [Array<Receiver>] Receiver array
+        def receiver(products = [PRODUCT], &block)
+          matcher = Core::Remote::Dispatcher::Matcher::Product.new(products)
+          [Core::Remote::Dispatcher::Receiver.new(matcher, &block)]
+        end
+
+        private
+
+        # Look up the telemetry component for error reporting. Returns nil if the
+        # component tree isn't built yet (very early boot) or the lookup raises.
+        # `allow_initialization: false` avoids triggering component-tree construction
+        # from inside an RC receiver callback.
+        # @return [Core::Telemetry::Component, nil]
+        # @api private
+        def lookup_telemetry
+          Datadog.send(:components, allow_initialization: false)&.telemetry
+        rescue
+          nil
+        end
+
+        # Process a single configuration change.
+        # @param component [Component] Symbol database component
+        # @param change [Change] Configuration change (:insert, :update, :delete)
+        # @param telemetry [Core::Telemetry::Component, nil] Telemetry for error reporting
+        # @return [void]
+        # @api private
+        def process_change(component, change, telemetry)
+          case change.type
+          when :insert
+            # @type var change: ::Datadog::Core::Remote::Configuration::Repository::Change::Inserted
+            enable_upload(component, change.content)
+            change.content.applied
+          when :update
+            # @type var change: ::Datadog::Core::Remote::Configuration::Repository::Change::Updated
+            disable_upload(component)
+            enable_upload(component, change.content)
+            change.content.applied
+          when :delete
+            # @type var change: ::Datadog::Core::Remote::Configuration::Repository::Change::Deleted
+            disable_upload(component)
+            change.previous&.applied
+          else
+            component.logger.debug { "symdb: unrecognized change type: #{change.type}" }
+            # Steep cannot narrow `change.content` from a respond_to? check — it sees
+            # the Repository::Change union type where `Deleted` lacks `content`.
+            change.content.errored("Unrecognized change type: #{change.type}") if change.respond_to?(:content) # steep:ignore NoMethod
+          end
+        rescue => e
+          component.logger.debug { "symdb: error processing remote config change: #{e.class}: #{e.message}" }
+          telemetry&.report(e, description: 'symdb: error processing remote config change')
+          # Rescue runs regardless of which branch raised — Steep cannot narrow the
+          # union type from a respond_to? check.
+          content_obj = change.respond_to?(:content) ? change.content : change.previous # steep:ignore NoMethod
+          content_obj&.errored(e.to_s)
+        end
+
+        # Enable upload if config has upload_symbols: true.
+        # @param component [Component] Symbol database component
+        # @param content [Content] Remote config content
+        # @return [void]
+        # @api private
+        def enable_upload(component, content)
+          config = parse_config(content, component.logger)
+
+          unless config
+            return
+          end
+
+          if config['upload_symbols']
+            component.logger.debug { "symdb: upload enabled via remote config" }
+            component.start_upload
+          else
+            component.logger.debug { "symdb: upload disabled in config" }
+          end
+        end
+
+        # Disable upload.
+        # @param component [Component] Symbol database component
+        # @return [void]
+        # @api private
+        def disable_upload(component)
+          component.logger.debug { "symdb: upload disabled via remote config" }
+          component.stop_upload
+        end
+
+        # Parse and validate remote config content.
+        # @param content [Content] Remote config content
+        # @param logger [SymbolDatabase::Logger] Logger for invalid-config diagnostics
+        # @return [Hash, nil] Parsed config or nil if invalid
+        # @api private
+        #
+        # JSON::ParserError is intentionally NOT rescued here — it propagates to
+        # process_change's rescue, which logs and reports to telemetry. Catching
+        # it locally would swallow the error from telemetry observability.
+        def parse_config(content, logger)
+          config = JSON.parse(content.data)
+
+          unless config.is_a?(Hash)
+            logger.debug { "symdb: invalid config format: expected Hash, got #{config.class}" }
+            return nil
+          end
+
+          unless config.key?('upload_symbols')
+            logger.debug { "symdb: missing 'upload_symbols' key in config" }
+            return nil
+          end
+
+          config
+        end
+      end
+    end
+  end
+end

data/lib/datadog/symbol_database/scope_batcher.rb

@@ -91,6 +91,14 @@ module Datadog
             return
           end
 
+          # Marked uploaded before perform_upload runs. This is intentional:
+          # symdb extraction is a one-shot operation per process — extract_all
+          # walks ObjectSpace once and never revisits a module within the same
+          # process. The Set deduplicates within a single extraction run, not
+          # across upload attempts. Failed uploads are not retried; symbols
+          # from a failed batch are lost until the next process restart, by
+          # design (matches Python and Go; Java retries via OkHttp, .NET via
+          # exponential backoff — Ruby does neither).
           @uploaded_modules.add(scope.name)
           @file_count += 1
 

data/lib/datadog/symbol_database/service_version.rb

@@ -16,15 +16,18 @@ module Datadog
     #
     # @api private
     class ServiceVersion
-      attr_reader :service, :env, :version, :language, :scopes
+      attr_reader :service, :env, :version, :language, :scopes, :upload_id, :batch_num, :final
 
       # Initialize a new ServiceVersion
       # @param service [String] Service name (required, from DD_SERVICE)
       # @param env [String, nil] Environment (from DD_ENV, passed through unchanged)
       # @param version [String, nil] Version (from DD_VERSION, passed through unchanged)
       # @param scopes [Array<Scope>] Top-level scopes (required)
+      # @param upload_id [String, nil] UUID identifying the logical upload (shared by all batches)
+      # @param batch_num [Integer, nil] 1-indexed batch number within the upload
+      # @param final [Boolean, nil] true if this is the last batch of the upload
       # @raise [ArgumentError] if service empty or scopes not an array
-      def initialize(service:, env:, version:, scopes:)
+      def initialize(service:, env:, version:, scopes:, upload_id: nil, batch_num: nil, final: nil)
         raise ArgumentError, 'service is required' if service.nil? || service.empty?
         raise ArgumentError, 'scopes must be an array' unless scopes.is_a?(Array)
 
@@ -33,6 +36,9 @@ module Datadog
         @version = version
         @language = 'ruby'
         @scopes = scopes
+        @upload_id = upload_id
+        @batch_num = batch_num
+        @final = final
       end
 
       # Convert service version to Hash for JSON serialization.
@@ -44,6 +50,9 @@ module Datadog
           version: version,
           language: language,
           scopes: scopes.map(&:to_h),
+          upload_id: upload_id,
+          batch_num: batch_num,
+          final: final,
         }
       end
 

data/lib/datadog/symbol_database/symbol.rb

@@ -42,17 +42,20 @@ module Datadog
       end
 
       # Convert symbol to Hash for JSON serialization.
-      # Removes nil values to reduce payload size.
+      # The `type` key is always present per the symdb JSON schema — emit nil
+      # when the type cannot be determined (the common case in Ruby since
+      # parameters and instance variables carry no declared type).
+      # `language_specifics` is omitted when nil to reduce payload size.
       # @return [Hash] Symbol as hash with symbol keys
       def to_h
+        # @type var h: Hash[::Symbol, untyped]
         h = {
           symbol_type: symbol_type,
           name: name,
           line: line,
           type: type,
-          language_specifics: language_specifics,
         }
-        h.compact!
+        h[:language_specifics] = language_specifics if language_specifics
         h
       end
 

data/lib/datadog/symbol_database/uploader.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'securerandom'
 require 'zlib'
 require 'stringio'
 require_relative '../core/environment/identity'
@@ -45,6 +46,12 @@ module Datadog
           agent_settings: agent_settings,
           logger: @logger,
         )
+
+        # Protects the lazy initialization of @upload_pid/@upload_id and the
+        # @batch_num increment in next_upload_metadata. ScopeBatcher calls
+        # upload_scopes outside its own mutex, so two threads (e.g. a size-
+        # triggered flush and the timer/shutdown path) can race here.
+        @metadata_mutex = Mutex.new
       end
 
       # Upload a batch of scopes to the agent.
@@ -56,7 +63,8 @@ module Datadog
       def upload_scopes(scopes)
         return if scopes.empty?
 
-        json_data = build_symbol_payload(scopes)
+        upload_id, batch_num = next_upload_metadata
+        json_data = build_symbol_payload(scopes, upload_id: upload_id, batch_num: batch_num)
         compressed_data = Zlib.gzip(json_data)
 
         # Emitted unconditionally so the rare oversized case is observable.
@@ -72,7 +80,7 @@ module Datadog
           return
         end
 
-        perform_http_upload(compressed_data, scopes.size)
+        perform_http_upload(compressed_data, scopes.size, upload_id: upload_id, batch_num: batch_num)
       rescue => e
         @logger.debug { "symdb: upload failed: #{e.class}: #{e.message}" }
         @telemetry&.report(e, description: 'symdb: upload failed')
@@ -82,31 +90,44 @@ module Datadog
 
       # Build JSON payload from scopes.
       # @param scopes [Array<Scope>] Scopes to serialize
+      # @param upload_id [String] UUID identifying the logical upload
+      # @param batch_num [Integer] 1-indexed batch number within the upload
       # @return [String] JSON string
-      def build_symbol_payload(scopes)
+      def build_symbol_payload(scopes, upload_id:, batch_num:)
         ServiceVersion.new(
           service: @settings.service,
           env: @settings.env,
           version: @settings.version,
           scopes: scopes,
+          upload_id: upload_id,
+          batch_num: batch_num,
+          # Always false: the Ruby tracer continuously uploads new code
+          # as files are loaded; there is no defined end-of-upload point.
+          final: false,
         ).to_json
       end
 
       # Perform HTTP POST with multipart form-data via transport layer.
       # @param compressed_data [String] GZIP compressed JSON payload
       # @param scope_count [Integer] Number of scopes (for logging)
+      # @param upload_id [String] UUID identifying the logical upload
+      # @param batch_num [Integer] 1-indexed batch number within the upload
       # @return [void]
-      def perform_http_upload(compressed_data, scope_count)
-        form = build_multipart_form(compressed_data)
+      def perform_http_upload(compressed_data, scope_count, upload_id:, batch_num:)
+        form = build_multipart_form(compressed_data, upload_id: upload_id, batch_num: batch_num)
         response = @transport.send_symbols(form)
         handle_response(response, scope_count)
       end
 
       # Build multipart form-data with event metadata and compressed symbols.
       # @param compressed_data [String] GZIP compressed JSON payload
+      # @param upload_id [String] UUID identifying the logical upload
+      # @param batch_num [Integer] 1-indexed batch number within the upload
       # @return [Hash] Form data hash with UploadIO objects
-      def build_multipart_form(compressed_data)
-        event_io = StringIO.new(build_event_metadata)
+      def build_multipart_form(compressed_data, upload_id:, batch_num:)
+        event_io = StringIO.new(
+          build_event_metadata(compressed_data.bytesize, upload_id: upload_id, batch_num: batch_num),
+        )
         file_io = StringIO.new(compressed_data)
 
         event_upload = Datadog::Core::Vendor::Multipart::Post::UploadIO.new(
@@ -128,17 +149,50 @@ module Datadog
       end
 
       # Build event.json metadata part.
+      # @param attachment_size [Integer] Size of the compressed attachment in bytes
+      # @param upload_id [String] UUID identifying the logical upload
+      # @param batch_num [Integer] 1-indexed batch number within the upload
       # @return [String] JSON string for event metadata
-      def build_event_metadata
+      def build_event_metadata(attachment_size, upload_id:, batch_num:)
         JSON.generate(
           ddsource: 'ruby',
           service: @settings.service,
+          version: @settings.version,
+          language: 'ruby',
           runtimeId: Datadog::Core::Environment::Identity.id,
           parentId: nil,  # Fork tracking deferred for MVP
           type: 'symdb',
+          uploadId: upload_id,
+          batchNum: batch_num,
+          # Always false: the Ruby tracer continuously uploads new code
+          # as files are loaded; there is no defined end-of-upload point.
+          final: false,
+          attachmentSize: attachment_size,
         )
       end
 
+      # Return [upload_id, batch_num] for the current process. upload_id is
+      # generated lazily on first use and shared by all batches uploaded from
+      # the process. A forked child observes a different Process.pid and
+      # therefore gets a fresh upload_id and batch counter.
+      # Synchronized: ScopeBatcher releases its mutex before calling
+      # upload_scopes, so this can be entered concurrently.
+      # @return [Array<(String, Integer)>]
+      def next_upload_metadata
+        @metadata_mutex.synchronize do
+          if @upload_pid != Process.pid
+            @upload_pid = Process.pid
+            @upload_id = SecureRandom.uuid.freeze
+            @batch_num = 0
+          end
+          @batch_num += 1 # steep:ignore NoMethod
+          # @upload_id and @batch_num are non-nil after the branch above; refine for Steep.
+          upload_id = @upload_id or raise('unreachable: @upload_id should be set')
+          batch_num = @batch_num or raise('unreachable: @batch_num should be set')
+          [upload_id, batch_num]
+        end
+      end
+
       # Handle HTTP response and track metrics.
       # @param response [Core::Transport::Response] HTTP response from agent
       # @param scope_count [Integer] Number of scopes uploaded

data/lib/datadog/tracing/contrib/action_pack/action_dispatch/instrumentation.rb

@@ -11,6 +11,8 @@ module Datadog
           module Instrumentation
             SCRIPT_NAME_KEY = 'SCRIPT_NAME'
             FORMAT_SUFFIX = '(.:format)'
+            # NOTE: Rails 8.1.1+ natively provides the same object via 'action_dispatch.route'.
+            DATADOG_RAILS_ROUTE_ENV_KEY = 'datadog.action_dispatch.route'
 
             module_function
 
@@ -48,6 +50,8 @@ module Datadog
                   result.each do |_, _, route|
                     next unless Instrumentation.dispatcher_route?(route)
 
+                    req.env[DATADOG_RAILS_ROUTE_ENV_KEY] = route
+
                     http_route = route.path.spec.to_s
                     http_route.delete_suffix!(FORMAT_SUFFIX)
 
@@ -66,6 +70,8 @@ module Datadog
                 def find_routes(req)
                   super do |match, parameters, route|
                     if Instrumentation.dispatcher_route?(route)
+                      req.env[DATADOG_RAILS_ROUTE_ENV_KEY] = route
+
                       http_route = route.path.spec.to_s
                       http_route.delete_suffix!(FORMAT_SUFFIX)
 
@@ -86,6 +92,8 @@ module Datadog
 
                   super do |route, parameters|
                     if Instrumentation.dispatcher_route?(route)
+                      req.env[DATADOG_RAILS_ROUTE_ENV_KEY] = route
+
                       http_route = route.path.spec.to_s
                       http_route = http_route.delete_suffix(FORMAT_SUFFIX)
 

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

@@ -48,10 +48,6 @@ 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/events/cache.rb

@@ -82,10 +82,6 @@ module Datadog
                 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
-
                 span.set_tag(Ext::TAG_CACHE_BACKEND, cache_backend(store))
 
                 span.set_tag('EVENT', event)

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

@@ -54,10 +54,6 @@ module Datadog
                 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
-
                 span.set_tag(Ext::TAG_CACHE_BACKEND, store) if store
 
                 set_cache_key(span, key, multi_key) if Datadog.configuration.tracing[:active_support][:cache_key].enabled

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

@@ -61,11 +61,6 @@ 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/dalli/instrumentation.rb

@@ -31,11 +31,6 @@ 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/elasticsearch/patcher.rb

@@ -66,11 +66,6 @@ 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.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

@@ -144,11 +144,6 @@ 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,14 +69,6 @@ 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

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../metadata/ext'
+
 module Datadog
   module Tracing
     module Contrib
@@ -60,9 +62,6 @@ 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

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

@@ -56,11 +56,6 @@ 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/grpc/datadog_interceptor/client.rb

@@ -59,11 +59,6 @@ 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)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_CLIENT)