ddtrace 1.4.2 → 1.19.0

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

@@ -1,14 +1,16 @@
-# typed: false
-
 require 'date'
 
 require_relative '../../../core/environment/variable_helpers'
+require_relative '../../../core/backport'
+require_relative '../../client_ip'
 require_relative '../../metadata/ext'
 require_relative '../../propagation/http'
 require_relative '../analytics'
+require_relative '../utils/quantization/http'
 require_relative 'ext'
+require_relative 'header_collection'
+require_relative 'header_tagging'
 require_relative 'request_queue'
-require_relative '../utils/quantization/http'
 
 module Datadog
   module Tracing
@@ -33,37 +35,54 @@ module Datadog
             request_start = Contrib::Rack::QueueTime.get_request_start(env)
             return if request_start.nil?
 
-            frontend_span = Tracing.trace(
-              Ext::SPAN_HTTP_SERVER_QUEUE,
-              span_type: Tracing::Metadata::Ext::HTTP::TYPE_PROXY,
-              start_time: request_start,
-              service: configuration[:web_service_name]
-            )
-
-            # Tag this span as belonging to Rack
-            frontend_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
-            frontend_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_HTTP_SERVER_QUEUE)
-
-            # Set peer service (so its not believed to belong to this app)
-            frontend_span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, configuration[:web_service_name])
-
-            frontend_span
+            case configuration[:request_queuing]
+            when true, :include_request # DEV: Switch `true` to `:exclude_request` in v2.0
+              queue_span = trace_http_server(Ext::SPAN_HTTP_SERVER_QUEUE, start_time: request_start)
+              # Tag this span as belonging to Rack
+              queue_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              queue_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_HTTP_SERVER_QUEUE)
+              queue_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
+              queue_span
+            when :exclude_request
+              request_span = trace_http_server(Ext::SPAN_HTTP_PROXY_REQUEST, start_time: request_start)
+              request_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT_HTTP_PROXY)
+              request_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_HTTP_PROXY_REQUEST)
+              request_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_PROXY)
+
+              queue_span = trace_http_server(Ext::SPAN_HTTP_PROXY_QUEUE, start_time: request_start)
+
+              # Measure service stats
+              Contrib::Analytics.set_measured(queue_span)
+
+              queue_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT_HTTP_PROXY)
+              queue_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_HTTP_PROXY_QUEUE)
+              queue_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_PROXY)
+              # finish the `queue` span now to record only the time spent *in queue*,
+              # excluding the time spent processing the request itself
+              queue_span.finish
+
+              request_span
+            end
           end
 
           def call(env)
             # Find out if this is rack within rack
             previous_request_span = env[Ext::RACK_ENV_REQUEST_SPAN]
 
+            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] && previous_request_span.nil?
+            if configuration[:distributed_tracing]
               trace_digest = Tracing::Propagation::HTTP.extract(env)
               Tracing.continue_trace!(trace_digest)
             end
 
             # Create a root Span to keep track of frontend web servers
             # (i.e. Apache, nginx) if the header is properly set
-            frontend_span = compute_queue_time(env) if previous_request_span.nil?
+            frontend_span = compute_queue_time(env)
 
             trace_options = { span_type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND }
             trace_options[:service] = configuration[:service_name] if configuration[:service_name]
@@ -121,20 +140,15 @@ module Datadog
           # rubocop:disable Metrics/PerceivedComplexity
           # rubocop:disable Metrics/MethodLength
           def set_request_tags!(trace, request_span, env, status, headers, response, original_env)
-            # http://www.rubydoc.info/github/rack/rack/file/SPEC
-            # The source of truth in Rack is the PATH_INFO key that holds the
-            # URL for the current request; but some frameworks may override that
-            # value, especially during exception handling.
-            #
-            # Because of this, we prefer to use REQUEST_URI, if available, which is the
-            # relative path + query string, and doesn't mutate.
-            #
-            # REQUEST_URI is only available depending on what web server is running though.
-            # So when its not available, we want the original, unmutated PATH_INFO, which
-            # is just the relative path without query strings.
-            url = env['REQUEST_URI'] || original_env['PATH_INFO']
-            request_headers = parse_request_headers(env)
-            response_headers = parse_response_headers(headers || {})
+            request_header_collection = Header::RequestHeaderCollection.new(env)
+
+            # 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
+            original_request_method = original_env['REQUEST_METHOD']
+
+            # request_headers is subject to filtering and configuration so we
+            # get the user agent separately
+            user_agent = parse_user_agent_header(request_header_collection)
 
             # The priority
             # 1. User overrides span.resource
@@ -143,11 +157,11 @@ module Datadog
             # 4. Fallback with verb + status, eq `GET 200`
             request_span.resource ||=
               if configuration[:middleware_names] && env['RESPONSE_MIDDLEWARE']
-                "#{env['RESPONSE_MIDDLEWARE']}##{env['REQUEST_METHOD']}"
+                "#{env['RESPONSE_MIDDLEWARE']}##{original_request_method}"
               elsif trace.resource_override?
                 trace.resource
               else
-                "#{env['REQUEST_METHOD']} #{status}".strip
+                "#{original_request_method} #{status}".strip
               end
 
             # Overrides the trace resource if it never been set
@@ -156,6 +170,7 @@ module Datadog
 
             request_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
             request_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
+            request_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
 
             # Set analytics sample rate
             if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
@@ -166,11 +181,17 @@ module Datadog
             Contrib::Analytics.set_measured(request_span)
 
             if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD).nil?
-              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, env['REQUEST_METHOD'])
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, original_request_method)
             end
 
+            url = parse_url(env, original_env)
+
             if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_URL).nil?
-              options = configuration[:quantize]
+              options = configuration[:quantize] || {}
+
+              # Quantization::HTTP.url base defaults to :show, but we are transitioning
+              options[:base] ||= :exclude
+
               request_span.set_tag(
                 Tracing::Metadata::Ext::HTTP::TAG_URL,
                 Contrib::Utils::Quantization::HTTP.url(url, options)
@@ -178,31 +199,38 @@ module Datadog
             end
 
             if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_BASE_URL).nil?
-              request_obj = ::Rack::Request.new(env)
+              options = configuration[:quantize]
 
-              base_url = if request_obj.respond_to?(:base_url)
-                           request_obj.base_url
-                         else
-                           # Compatibility for older Rack versions
-                           request_obj.url.chomp(request_obj.fullpath)
-                         end
+              unless options[:base] == :show
+                base_url = Contrib::Utils::Quantization::HTTP.base_url(url)
 
-              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_BASE_URL, base_url)
+                unless base_url.empty?
+                  request_span.set_tag(
+                    Tracing::Metadata::Ext::HTTP::TAG_BASE_URL,
+                    base_url
+                  )
+                end
+              end
+            end
+
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_CLIENT_IP).nil?
+              Tracing::ClientIp.set_client_ip_tag(
+                request_span,
+                headers: request_header_collection,
+                remote_ip: env['REMOTE_ADDR']
+              )
             end
 
             if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE).nil? && status
               request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, status)
             end
 
-            # Request headers
-            request_headers.each do |name, value|
-              request_span.set_tag(name, value) if request_span.get_tag(name).nil?
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT).nil? && user_agent
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT, user_agent)
             end
 
-            # Response headers
-            response_headers.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
@@ -219,38 +247,59 @@ module Datadog
             Datadog.configuration.tracing[:rack]
           end
 
-          def parse_request_headers(env)
-            {}.tap do |result|
-              whitelist = configuration[:headers][:request] || []
-              whitelist.each do |header|
-                rack_header = header_to_rack_header(header)
-                if env.key?(rack_header)
-                  result[Tracing::Metadata::Ext::HTTP::RequestHeaders.to_tag(header)] = env[rack_header]
-                end
-              end
-            end
+          def trace_http_server(span_name, start_time:)
+            Tracing.trace(
+              span_name,
+              span_type: Tracing::Metadata::Ext::HTTP::TYPE_PROXY,
+              start_time: start_time,
+              service: configuration[:web_service_name]
+            )
           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
+          def parse_url(env, original_env)
+            request_obj = ::Rack::Request.new(env)
+
+            # scheme, host, and port
+            base_url = if request_obj.respond_to?(:base_url)
+                         request_obj.base_url
+                       else
+                         # Compatibility for older Rack versions
+                         request_obj.url.chomp(request_obj.fullpath)
+                       end
+
+            # https://github.com/rack/rack/blob/main/SPEC.rdoc
+            #
+            # The source of truth in Rack is the PATH_INFO key that holds the
+            # URL for the current request; but some frameworks may override that
+            # value, especially during exception handling.
+            #
+            # Because of this, we prefer to use REQUEST_URI, if available, which is the
+            # relative path + query string, and doesn't mutate.
+            #
+            # REQUEST_URI is only available depending on what web server is running though.
+            # So when its not available, we want the original, unmutated PATH_INFO, which
+            # is just the relative path without query strings.
+            #
+            # SCRIPT_NAME is the first part of the request URL path, so that
+            # the application can know its virtual location. It should be
+            # prepended to PATH_INFO to reflect the correct user visible path.
+            request_uri = env['REQUEST_URI'].to_s
+            fullpath = if request_uri.empty?
+                         query_string = original_env['QUERY_STRING'].to_s
+                         path = original_env['SCRIPT_NAME'].to_s + original_env['PATH_INFO'].to_s
+
+                         query_string.empty? ? path : "#{path}?#{query_string}"
+                       else
+                         # normally REQUEST_URI starts at the path, but it
+                         # might contain the full URL in some cases (e.g WEBrick)
+                         Datadog::Core::BackportFrom25.string_delete_prefix(request_uri, base_url)
+                       end
+
+            base_url + fullpath
           end
 
-          def header_to_rack_header(name)
-            "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
+          def parse_user_agent_header(headers)
+            headers.get(Tracing::Metadata::Ext::HTTP::HEADER_USER_AGENT)
           end
         end
       end

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

@@ -1,5 +1,3 @@
-# typed: false
-
 module Datadog
   module Tracing
     module Contrib

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

@@ -1,5 +1,3 @@
-# typed: true
-
 module Datadog
   module Tracing
     module Contrib

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

@@ -1,7 +1,3 @@
-# typed: ignore
-
-require_relative '../auto_instrument'
-
 # Railtie to include AutoInstrumentation in rails loading
 class DatadogAutoInstrumentRailtie < Rails::Railtie
   # we want to load before config initializers so that any user supplied config

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

@@ -1,7 +1,7 @@
-# typed: false
-
 require_relative '../../configuration/settings'
 
+require_relative '../../../../core'
+
 module Datadog
   module Tracing
     module Contrib
@@ -24,44 +24,53 @@ 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.on_set do |value|
+              o.type :bool, nilable: true
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.after_set do |value|
                 # Update ActionPack analytics too
                 Datadog.configuration.tracing[:action_pack][:analytics_enabled] = value
               end
             end
 
             option :analytics_sample_rate do |o|
-              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
-              o.lazy
-              o.on_set do |value|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+              o.after_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|
-                # Update ActionPack exception controller too
-                Datadog.configuration.tracing[:action_pack][:exception_controller] = value
+              o.after_set do |value|
+                if value
+                  Datadog::Core.log_deprecation do
+                    'The error controller is now automatically detected. '\
+                    "Option `#{o.instance_variable_get(:@name)}` is no longer required and will be removed."
+                  end
+                end
               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|
+              o.after_set do |value|
                 # Update ActionView template base path too
                 Datadog.configuration.tracing[:action_view][:template_base_path] = value
               end

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

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Tracing
@@ -7,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/framework.rb

@@ -1,4 +1,4 @@
-# typed: false
+# frozen_string_literal: true
 
 require_relative '../action_cable/integration'
 require_relative '../action_mailer/integration'

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

@@ -1,5 +1,3 @@
-# typed: false
-
 require_relative '../integration'
 
 require_relative 'ext'

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

@@ -1,5 +1,3 @@
-# typed: false
-
 module Datadog
   module Tracing
     module Contrib
@@ -9,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/middlewares.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 require_relative '../action_pack/utils'
 

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

@@ -1,5 +1,3 @@
-# typed: ignore
-
 require_relative '../../../core/utils/only_once'
 require_relative '../rack/middlewares'
 require_relative 'framework'
@@ -26,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
 
@@ -63,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.

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

@@ -1,5 +1,3 @@
-# typed: ignore
-
 require_relative 'framework'
 require_relative 'middlewares'
 require_relative '../rack/middlewares'
@@ -8,12 +6,12 @@ module Datadog
   # Railtie class initializes
   class Railtie < Rails::Railtie
     # Add the trace middleware to the application stack
-    initializer 'datadog.before_intialize' do |app|
-      Tracing::Contrib::Rails::Patcher.before_intialize(app)
+    initializer 'datadog.before_initialize' do |app|
+      Tracing::Contrib::Rails::Patcher.before_initialize(app)
     end
 
     config.after_initialize do
-      Tracing::Contrib::Rails::Patcher.after_intialize(self)
+      Tracing::Contrib::Rails::Patcher.after_initialize(self)
     end
   end
 end

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

@@ -1,4 +1,4 @@
-# typed: false
+# frozen_string_literal: true
 
 require_relative '../analytics'
 
@@ -19,7 +19,7 @@ module Datadog
           end
 
           def self.railtie_supported?
-            !(defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR >= 3 && defined?(::Rails::Railtie)).nil?
+            !!(defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR >= 3 && defined?(::Rails::Railtie))
           end
         end
       end