ddtrace 1.12.1 → 1.14.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Tracing
     module Contrib
@@ -5,18 +7,18 @@ module Datadog
         # Qless integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_QLESS_ANALYTICS_ENABLED'.freeze
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_QLESS_ANALYTICS_SAMPLE_RATE'.freeze
-          ENV_TAG_JOB_DATA = 'DD_QLESS_TAG_JOB_DATA'.freeze
-          ENV_TAG_JOB_TAGS = 'DD_QLESS_TAG_JOB_TAGS'.freeze
-          SERVICE_NAME = 'qless'.freeze
-          SPAN_JOB = 'qless.job'.freeze
-          TAG_JOB_ID = 'qless.job.id'.freeze
-          TAG_JOB_DATA = 'qless.job.data'.freeze
-          TAG_JOB_QUEUE = 'qless.job.queue'.freeze
-          TAG_JOB_TAGS = 'qless.job.tags'.freeze
-          TAG_COMPONENT = 'qless'.freeze
-          TAG_OPERATION_JOB = 'job'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_QLESS_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_QLESS_ANALYTICS_SAMPLE_RATE'
+          ENV_TAG_JOB_DATA = 'DD_QLESS_TAG_JOB_DATA'
+          ENV_TAG_JOB_TAGS = 'DD_QLESS_TAG_JOB_TAGS'
+          SERVICE_NAME = 'qless'
+          SPAN_JOB = 'qless.job'
+          TAG_JOB_ID = 'qless.job.id'
+          TAG_JOB_DATA = 'qless.job.data'
+          TAG_JOB_QUEUE = 'qless.job.queue'
+          TAG_JOB_TAGS = 'qless.job.tags'
+          TAG_COMPONENT = 'qless'
+          TAG_OPERATION_JOB = 'job'
         end
       end
     end

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

@@ -12,33 +12,42 @@ module Datadog
           # Default settings for the Que integration
           class Settings < Contrib::Configuration::Settings
             option :service_name
-            option :distributed_tracing, default: true
+            option :distributed_tracing, default: true, type: :bool
 
             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 :tag_args do |o|
-              o.default { env_to_bool(Ext::ENV_TAG_ARGS_ENABLED, false) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_TAG_ARGS_ENABLED
+              o.default false
             end
 
             option :tag_data do |o|
-              o.default { env_to_bool(Ext::ENV_TAG_DATA_ENABLED, false) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_TAG_DATA_ENABLED
+              o.default false
+            end
+
+            option :error_handler do |o|
+              o.type :proc
+              o.experimental_default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
             end
-            option :error_handler, default: Tracing::SpanOperation::Events::DEFAULT_ON_ERROR
           end
         end
       end

data/lib/datadog/tracing/contrib/racecar/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 :service_name do |o|
@@ -33,7 +36,6 @@ module Datadog
                   Ext::DEFAULT_PEER_SERVICE_NAME
                 )
               end
-              o.lazy
             end
           end
         end

data/lib/datadog/tracing/contrib/racecar/event.rb

@@ -40,11 +40,6 @@ module Datadog
               span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_MESSAGING_SYSTEM)
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
 
-              # 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
-
               # 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/racecar/ext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Tracing
     module Contrib
@@ -5,24 +7,24 @@ module Datadog
         # Racecar integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_RACECAR_ENABLED'.freeze
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RACECAR_ANALYTICS_ENABLED'.freeze
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RACECAR_ANALYTICS_SAMPLE_RATE'.freeze
-          DEFAULT_PEER_SERVICE_NAME = 'racecar'.freeze
-          SPAN_CONSUME = 'racecar.consume'.freeze
-          SPAN_BATCH = 'racecar.batch'.freeze
-          SPAN_MESSAGE = 'racecar.message'.freeze
-          TAG_CONSUMER = 'kafka.consumer'.freeze
-          TAG_FIRST_OFFSET = 'kafka.first_offset'.freeze
-          TAG_MESSAGE_COUNT = 'kafka.message_count'.freeze
-          TAG_OFFSET = 'kafka.offset'.freeze
-          TAG_PARTITION = 'kafka.partition'.freeze
-          TAG_TOPIC = 'kafka.topic'.freeze
-          TAG_COMPONENT = 'racecar'.freeze
-          TAG_OPERATION_CONSUME = 'consume'.freeze
-          TAG_OPERATION_BATCH = 'batch'.freeze
-          TAG_OPERATION_MESSAGE = 'message'.freeze
-          TAG_MESSAGING_SYSTEM = 'kafka'.freeze
+          ENV_ENABLED = 'DD_TRACE_RACECAR_ENABLED'
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RACECAR_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RACECAR_ANALYTICS_SAMPLE_RATE'
+          DEFAULT_PEER_SERVICE_NAME = 'racecar'
+          SPAN_CONSUME = 'racecar.consume'
+          SPAN_BATCH = 'racecar.batch'
+          SPAN_MESSAGE = 'racecar.message'
+          TAG_CONSUMER = 'kafka.consumer'
+          TAG_FIRST_OFFSET = 'kafka.first_offset'
+          TAG_MESSAGE_COUNT = 'kafka.message_count'
+          TAG_OFFSET = 'kafka.offset'
+          TAG_PARTITION = 'kafka.partition'
+          TAG_TOPIC = 'kafka.topic'
+          TAG_COMPONENT = 'racecar'
+          TAG_OPERATION_CONSUME = 'consume'
+          TAG_OPERATION_BATCH = 'batch'
+          TAG_OPERATION_MESSAGE = 'message'
+          TAG_MESSAGING_SYSTEM = 'kafka'
         end
       end
     end

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

@@ -17,30 +17,34 @@ module Datadog
             }.freeze
 
             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, nil) }
-              o.lazy
+              o.type :bool, nilable: true
+              o.env Ext::ENV_ANALYTICS_ENABLED
             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 :application
-            option :distributed_tracing, default: true
-            option :headers, default: DEFAULT_HEADERS
-            option :middleware_names, default: false
-            option :quantize, default: {}
-            option :request_queuing, default: false
+            option :distributed_tracing, default: true, type: :bool
+            option :headers, default: DEFAULT_HEADERS, type: :hash
+            option :middleware_names, default: false, type: :bool
+            option :quantize, default: {}, type: :hash
+            option :request_queuing do |o|
+              o.default false
+            end
 
             option :service_name
 
-            option :web_service_name, default: Ext::DEFAULT_PEER_WEBSERVER_SERVICE_NAME
+            option :web_service_name, default: Ext::DEFAULT_PEER_WEBSERVER_SERVICE_NAME, type: :string
           end
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Tracing
     module Contrib
@@ -5,22 +7,22 @@ module Datadog
         # Rack integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_RACK_ENABLED'.freeze
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RACK_ANALYTICS_ENABLED'.freeze
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RACK_ANALYTICS_SAMPLE_RATE'.freeze
-          RACK_ENV_REQUEST_SPAN = 'datadog.rack_request_span'.freeze
-          SPAN_HTTP_PROXY_REQUEST = 'http.proxy.request'.freeze
-          SPAN_HTTP_PROXY_QUEUE = 'http.proxy.queue'.freeze
-          SPAN_HTTP_SERVER_QUEUE = 'http_server.queue'.freeze
-          SPAN_REQUEST = 'rack.request'.freeze
-          TAG_COMPONENT = 'rack'.freeze
-          TAG_COMPONENT_HTTP_PROXY = 'http_proxy'.freeze
-          TAG_OPERATION_REQUEST = 'request'.freeze
-          TAG_OPERATION_HTTP_PROXY_REQUEST = 'request'.freeze
-          TAG_OPERATION_HTTP_PROXY_QUEUE = 'queue'.freeze
-          TAG_OPERATION_HTTP_SERVER_QUEUE = 'queue'.freeze
-          WEBSERVER_APP = 'webserver'.freeze
-          DEFAULT_PEER_WEBSERVER_SERVICE_NAME = 'web-server'.freeze
+          ENV_ENABLED = 'DD_TRACE_RACK_ENABLED'
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RACK_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RACK_ANALYTICS_SAMPLE_RATE'
+          RACK_ENV_REQUEST_SPAN = 'datadog.rack_request_span'
+          SPAN_HTTP_PROXY_REQUEST = 'http.proxy.request'
+          SPAN_HTTP_PROXY_QUEUE = 'http.proxy.queue'
+          SPAN_HTTP_SERVER_QUEUE = 'http_server.queue'
+          SPAN_REQUEST = 'rack.request'
+          TAG_COMPONENT = 'rack'
+          TAG_COMPONENT_HTTP_PROXY = 'http_proxy'
+          TAG_OPERATION_REQUEST = 'request'
+          TAG_OPERATION_HTTP_PROXY_REQUEST = 'request'
+          TAG_OPERATION_HTTP_PROXY_QUEUE = 'queue'
+          TAG_OPERATION_HTTP_SERVER_QUEUE = 'queue'
+          WEBSERVER_APP = 'webserver'
+          DEFAULT_PEER_WEBSERVER_SERVICE_NAME = 'web-server'
         end
       end
     end

data/lib/datadog/tracing/contrib/rack/header_collection.rb

@@ -19,6 +19,9 @@ module Datadog
               @env[Header.to_rack_header(header_name)]
             end
 
+            # Allows this class to have a similar API to a {Hash}.
+            alias [] get
+
             # Tests whether a header with the given name exists in the environment.
             def key?(header_name)
               @env.key?(Header.to_rack_header(header_name))

data/lib/datadog/tracing/contrib/rack/header_tagging.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rack
+        # Matches Rack-style headers with a matcher and sets matching headers into a span.
+        module HeaderTagging
+          def self.tag_request_headers(span, env, configuration)
+            # Wrap env in a case-insensitive Rack-style accessor.
+            headers = env.is_a?(Header::RequestHeaderCollection) ? env : Header::RequestHeaderCollection.new(env)
+
+            # Use global DD_TRACE_HEADER_TAGS if integration-level configuration is not provided
+            tags = if configuration.using_default?(:headers) && !Datadog.configuration.tracing.using_default?(:header_tags)
+                     Datadog.configuration.tracing.header_tags.request_tags(headers)
+                   else
+                     whitelist = configuration[:headers][:request] || []
+                     whitelist.each_with_object({}) do |header, result|
+                       header_value = headers.get(header)
+                       unless header_value.nil?
+                         header_tag = Tracing::Metadata::Ext::HTTP::RequestHeaders.to_tag(header)
+                         result[header_tag] = header_value
+                       end
+                     end
+                   end
+
+            span.set_tags(tags)
+          end
+
+          def self.tag_response_headers(span, headers, configuration)
+            headers = Core::Utils::Hash::CaseInsensitiveWrapper.new(headers) # Make header access case-insensitive
+
+            # Use global DD_TRACE_HEADER_TAGS if integration-level configuration is not provided
+            tags = if configuration.using_default?(:headers) && !Datadog.configuration.tracing.using_default?(:header_tags)
+                     Datadog.configuration.tracing.header_tags.response_tags(headers)
+                   else
+                     whitelist = configuration[:headers][:response] || []
+                     whitelist.each_with_object({}) do |header, result|
+                       header_value = headers[header]
+                       unless header_value.nil?
+                         header_tag = Tracing::Metadata::Ext::HTTP::ResponseHeaders.to_tag(header)
+                         result[header_tag] = header_value
+                       end
+                     end
+                   end
+
+            span.set_tags(tags)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/rack/middlewares.rb

@@ -1,6 +1,7 @@
 require 'date'
 
 require_relative '../../../core/environment/variable_helpers'
+require_relative '../../../core/backport'
 require_relative '../../client_ip'
 require_relative '../../metadata/ext'
 require_relative '../../propagation/http'
@@ -8,6 +9,7 @@ require_relative '../analytics'
 require_relative '../utils/quantization/http'
 require_relative 'ext'
 require_relative 'header_collection'
+require_relative 'header_tagging'
 require_relative 'request_queue'
 
 module Datadog
@@ -69,6 +71,8 @@ module Datadog
 
             return @app.call(env) if previous_request_span
 
+            Datadog::Core::Remote.active_remote.barrier(:once) unless Datadog::Core::Remote.active_remote.nil?
+
             # Extract distributed tracing context before creating any spans,
             # so that all spans will be added to the distributed trace.
             if configuration[:distributed_tracing]
@@ -137,8 +141,6 @@ module Datadog
           # rubocop:disable Metrics/MethodLength
           def set_request_tags!(trace, request_span, env, status, headers, response, original_env)
             request_header_collection = Header::RequestHeaderCollection.new(env)
-            request_headers_tags = parse_request_headers(request_header_collection)
-            response_headers_tags = parse_response_headers(headers || {})
 
             # Since it could be mutated, it would be more accurate to fetch from the original env,
             # e.g. ActionDispatch::ShowExceptions middleware with Rails exceptions_app configuration
@@ -227,15 +229,8 @@ module Datadog
               request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT, user_agent)
             end
 
-            # Request headers
-            request_headers_tags.each do |name, value|
-              request_span.set_tag(name, value) if request_span.get_tag(name).nil?
-            end
-
-            # Response headers
-            response_headers_tags.each do |name, value|
-              request_span.set_tag(name, value) if request_span.get_tag(name).nil?
-            end
+            HeaderTagging.tag_request_headers(request_span, request_header_collection, configuration)
+            HeaderTagging.tag_response_headers(request_span, headers, configuration) if headers
 
             # detect if the status code is a 5xx and flag the request span as an error
             # unless it has been already set by the underlying framework
@@ -253,19 +248,12 @@ module Datadog
           end
 
           def trace_http_server(span_name, start_time:)
-            span = Tracing.trace(
+            Tracing.trace(
               span_name,
               span_type: Tracing::Metadata::Ext::HTTP::TYPE_PROXY,
               start_time: start_time,
               service: configuration[:web_service_name]
             )
-
-            # Set peer service (so its not believed to belong to this app)
-            if Contrib::SpanAttributeSchema.default_span_attribute_schema?
-              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, configuration[:web_service_name])
-            end
-
-            span
           end
 
           def parse_url(env, original_env)
@@ -304,7 +292,7 @@ module Datadog
                        else
                          # normally REQUEST_URI starts at the path, but it
                          # might contain the full URL in some cases (e.g WEBrick)
-                         request_uri.sub(/^#{base_url}/, '')
+                         Datadog::Core::BackportFrom25.string_delete_prefix(request_uri, base_url)
                        end
 
             base_url + fullpath
@@ -313,35 +301,6 @@ module Datadog
           def parse_user_agent_header(headers)
             headers.get(Tracing::Metadata::Ext::HTTP::HEADER_USER_AGENT)
           end
-
-          def parse_request_headers(headers)
-            whitelist = configuration[:headers][:request] || []
-            whitelist.each_with_object({}) do |header, result|
-              header_value = headers.get(header)
-              unless header_value.nil?
-                header_tag = Tracing::Metadata::Ext::HTTP::RequestHeaders.to_tag(header)
-                result[header_tag] = header_value
-              end
-            end
-          end
-
-          def parse_response_headers(headers)
-            {}.tap do |result|
-              whitelist = configuration[:headers][:response] || []
-              whitelist.each do |header|
-                if headers.key?(header)
-                  result[Tracing::Metadata::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[header]
-                else
-                  # Try a case-insensitive lookup
-                  uppercased_header = header.to_s.upcase
-                  matching_header = headers.keys.find { |h| h.upcase == uppercased_header }
-                  if matching_header
-                    result[Tracing::Metadata::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[matching_header]
-                  end
-                end
-              end
-            end
-          end
         end
       end
     end

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

@@ -24,13 +24,14 @@ module Datadog
             end
 
             option :enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
-              o.lazy
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
             end
 
             option :analytics_enabled do |o|
-              o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, nil) }
-              o.lazy
+              o.type :bool, nilable: true
+              o.env Ext::ENV_ANALYTICS_ENABLED
               o.on_set do |value|
                 # Update ActionPack analytics too
                 Datadog.configuration.tracing[:action_pack][:analytics_enabled] = value
@@ -38,18 +39,20 @@ module Datadog
             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
               o.on_set do |value|
                 # Update ActionPack analytics too
                 Datadog.configuration.tracing[:action_pack][:analytics_sample_rate] = value
               end
             end
 
-            option :distributed_tracing, default: true
-
-            option :request_queuing, default: false
+            option :distributed_tracing, default: true, type: :bool
 
+            option :request_queuing do |o|
+              o.default false
+            end
             # DEV-2.0: Breaking changes for removal.
             option :exception_controller do |o|
               o.on_set do |value|
@@ -62,9 +65,10 @@ module Datadog
               end
             end
 
-            option :middleware, default: true
-            option :middleware_names, default: false
+            option :middleware, default: true, type: :bool
+            option :middleware_names, default: false, type: :bool
             option :template_base_path do |o|
+              o.type :string
               o.default 'views/'
               o.on_set do |value|
                 # Update ActionView template base path too

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

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

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

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

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

@@ -24,23 +24,24 @@ module Datadog
           end
 
           def patch
-            patch_before_intialize
-            patch_after_intialize
+            patch_before_initialize
+            patch_after_initialize
           end
 
-          def patch_before_intialize
+          def patch_before_initialize
             ::ActiveSupport.on_load(:before_initialize) do
-              Contrib::Rails::Patcher.before_intialize(self)
+              Contrib::Rails::Patcher.before_initialize(self)
             end
           end
 
-          def before_intialize(app)
+          def before_initialize(app)
             BEFORE_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
               # Middleware must be added before the application is initialized.
               # Otherwise the middleware stack will be frozen.
               # Sometimes we don't want to activate middleware e.g. OpenTracing, etc.
               add_middleware(app) if Datadog.configuration.tracing[:rails][:middleware]
-              add_logger(app) if Datadog.configuration.tracing.log_injection
+
+              Rails::LogInjection.configure_log_tags(app.config)
             end
           end
 
@@ -61,45 +62,13 @@ module Datadog
             app.middleware.insert_after(::ActionDispatch::DebugExceptions, Contrib::Rails::ExceptionMiddleware)
           end
 
-          def add_logger(app)
-            should_warn = true
-            # check if lograge key exists
-            # Note: Rails executes initializers sequentially based on alphabetical order,
-            # and lograge config could occur after datadog config.
-            # So checking for `app.config.lograge.enabled` may yield a false negative,
-            # and adding custom options naively if `config.lograge` exists from the lograge Railtie,
-            # is inconsistent since a lograge initializer would override it.
-            # Instead, we patch Lograge `custom_options` internals directly
-            # as part of Rails framework patching
-            # and just flag off the warning log here.
-            # SemanticLogger we similarly patch in the after_initiaize block, and should flag
-            # off the warning log here if we know we'll patch this gem later.
-            should_warn = false if app.config.respond_to?(:lograge) || defined?(::SemanticLogger)
-
-            # if lograge isn't set, check if tagged logged is enabled.
-            # if so, add proc that injects trace identifiers for tagged logging.
-            logger = app.config.logger || ::Rails.logger
-
-            if logger \
-                && defined?(::ActiveSupport::TaggedLogging) \
-                && logger.is_a?(::ActiveSupport::TaggedLogging)
-
-              Contrib::Rails::LogInjection.add_as_tagged_logging_logger(app)
-              should_warn = false
-            end
-
-            if should_warn
-              Datadog.logger.warn("Unable to enable Datadog Trace context, Logger #{logger.class} is not supported")
-            end
-          end
-
-          def patch_after_intialize
+          def patch_after_initialize
             ::ActiveSupport.on_load(:after_initialize) do
-              Contrib::Rails::Patcher.after_intialize(self)
+              Contrib::Rails::Patcher.after_initialize(self)
             end
           end
 
-          def after_intialize(app)
+          def after_initialize(app)
             AFTER_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
               # Finish configuring the tracer after the application is initialized.
               # We need to wait for some things, like application name, middleware stack, etc.