ddtrace 0.34.1 → 0.36.0

data/lib/ddtrace/contrib/http/instrumentation.rb

@@ -37,7 +37,7 @@ module Datadog
             pin = datadog_pin(request_options)
             return super(req, body, &block) unless pin && pin.tracer
 
-            if Datadog::Contrib::HTTP.should_skip_tracing?(req, @address, @port, pin.tracer)
+            if Datadog::Contrib::HTTP.should_skip_tracing?(req, pin.tracer)
               return super(req, body, &block)
             end
 
@@ -58,7 +58,7 @@ module Datadog
                 # Add additional request specific tags to the span.
                 annotate_span_with_request!(span, req, request_options)
               rescue StandardError => e
-                Datadog::Logger.log.error("error preparing span for http request: #{e}")
+                Datadog.logger.error("error preparing span for http request: #{e}")
               ensure
                 response = super(req, body, &block)
               end

data/lib/ddtrace/contrib/mongodb/subscribers.rb

@@ -50,7 +50,7 @@ module Datadog
           # the framework itself, so we set only the error and the message
           span.set_error(event)
         rescue StandardError => e
-          Datadog::Logger.log.debug("error when handling MongoDB 'failed' event: #{e}")
+          Datadog.logger.debug("error when handling MongoDB 'failed' event: #{e}")
         ensure
           # whatever happens, the Span must be removed from the local storage and
           # it must be finished to prevent any leak
@@ -66,7 +66,7 @@ module Datadog
           rows = event.reply.fetch('n', nil)
           span.set_tag(Ext::TAG_ROWS, rows) unless rows.nil?
         rescue StandardError => e
-          Datadog::Logger.log.debug("error when handling MongoDB 'succeeded' event: #{e}")
+          Datadog.logger.debug("error when handling MongoDB 'succeeded' event: #{e}")
         ensure
           # whatever happens, the Span must be removed from the local storage and
           # it must be finished to prevent any leak

data/lib/ddtrace/contrib/patchable.rb

@@ -47,7 +47,7 @@ module Datadog
             desc += ", Compatible? #{self.class.compatible?}"
             desc += ", Patchable? #{self.class.patchable?}"
 
-            Datadog::Logger.log.warn("Unable to patch #{self.class.name} (#{desc})")
+            Datadog.logger.warn("Unable to patch #{self.class.name} (#{desc})")
             return
           end
 

data/lib/ddtrace/contrib/patcher.rb

@@ -28,17 +28,17 @@ module Datadog
             begin
               super.tap do
                 # Emit a metric
-                Diagnostics::Health.metrics.instrumentation_patched(1, tags: default_tags)
+                Datadog.health_metrics.instrumentation_patched(1, tags: default_tags)
               end
             rescue StandardError => e
               # Log the error
-              Datadog::Logger.log.error("Failed to apply #{patch_name} patch. Cause: #{e} Location: #{e.backtrace.first}")
+              Datadog.logger.error("Failed to apply #{patch_name} patch. Cause: #{e} Location: #{e.backtrace.first}")
 
               # Emit a metric
               tags = default_tags
               tags << "error:#{e.class.name}"
 
-              Diagnostics::Health.metrics.error_instrumentation_patch(1, tags: tags)
+              Datadog.health_metrics.error_instrumentation_patch(1, tags: tags)
             end
           end
         end

data/lib/ddtrace/contrib/presto/instrumentation.rb

@@ -24,7 +24,7 @@ module Datadog
                   span.span_type = Datadog::Ext::SQL::TYPE
                   span.set_tag(Ext::TAG_QUERY_ASYNC, false)
                 rescue StandardError => e
-                  Datadog::Logger.log.debug("error preparing span for presto: #{e}")
+                  Datadog.logger.debug("error preparing span for presto: #{e}")
                 end
 
                 super(query)
@@ -39,7 +39,7 @@ module Datadog
                   span.span_type = Datadog::Ext::SQL::TYPE
                   span.set_tag(Ext::TAG_QUERY_ASYNC, !blk.nil?)
                 rescue StandardError => e
-                  Datadog::Logger.log.debug("error preparing span for presto: #{e}")
+                  Datadog.logger.debug("error preparing span for presto: #{e}")
                 end
 
                 super(query, &blk)
@@ -55,7 +55,7 @@ module Datadog
                   # ^ not an SQL type span, since there's no SQL query
                   span.set_tag(Ext::TAG_QUERY_ID, query_id)
                 rescue StandardError => e
-                  Datadog::Logger.log.debug("error preparing span for presto: #{e}")
+                  Datadog.logger.debug("error preparing span for presto: #{e}")
                 end
 
                 super(query_id)

data/lib/ddtrace/contrib/presto/patcher.rb

@@ -20,7 +20,7 @@ module Datadog
             begin
               ::Presto::Client::Client.send(:include, Instrumentation::Client)
             rescue StandardError => e
-              Datadog::Logger.log.error("Unable to apply Presto integration: #{e}")
+              Datadog.logger.error("Unable to apply Presto integration: #{e}")
             end
           end
         end

data/lib/ddtrace/contrib/rack/middlewares.rb

@@ -222,7 +222,7 @@ module Datadog
                 if key == :datadog_rack_request_span \
                   && @datadog_span_warning \
                   && @datadog_deprecation_warnings
-                  Datadog::Logger.log.warn(REQUEST_SPAN_DEPRECATION_WARNING)
+                  Datadog.logger.warn(REQUEST_SPAN_DEPRECATION_WARNING)
                   @datadog_span_warning = true
                 end
                 super
@@ -232,7 +232,7 @@ module Datadog
                 if key == :datadog_rack_request_span \
                   && @datadog_span_warning \
                   && @datadog_deprecation_warnings
-                  Datadog::Logger.log.warn(REQUEST_SPAN_DEPRECATION_WARNING)
+                  Datadog.logger.warn(REQUEST_SPAN_DEPRECATION_WARNING)
                   @datadog_span_warning = true
                 end
                 super

data/lib/ddtrace/contrib/rack/patcher.rb

@@ -38,7 +38,7 @@ module Datadog
           # context of middleware patching outside a Rails server process (eg. a
           # process that doesn't serve HTTP requests but has Rails environment
           # loaded such as a Resque master process)
-          Logger.log.debug("Error patching middleware stack: #{e}")
+          Datadog.logger.debug("Error patching middleware stack: #{e}")
         end
 
         def retain_middleware_name(middleware)
@@ -90,7 +90,7 @@ module Datadog
             if get_option(:application)
               MiddlewareNamePatcher.patch
             else
-              Datadog::Logger.log.warn(%(
+              Datadog.logger.warn(%(
               Rack :middleware_names requires you to also pass :application.
               Middleware names have NOT been patched; please provide :application.
               e.g. use: :rack, middleware_names: true, application: my_rack_app).freeze)

data/lib/ddtrace/contrib/rack/request_queue.rb

@@ -30,7 +30,7 @@ module Datadog
         rescue StandardError => e
           # in case of an Exception we don't create a
           # `request.queuing` span
-          Datadog::Logger.log.debug("[rack] unable to parse request queue headers: #{e}")
+          Datadog.logger.debug("[rack] unable to parse request queue headers: #{e}")
           nil
         end
       end

data/lib/ddtrace/contrib/rails/configuration/settings.rb

@@ -6,6 +6,19 @@ module Datadog
       module Configuration
         # Custom settings for the Rails integration
         class Settings < Contrib::Configuration::Settings
+          def initialize(options = {})
+            super(options)
+
+            # NOTE: Eager load these
+            #       Rails integration is responsible for orchestrating other integrations.
+            #       When using environment variables, settings will not be automatically
+            #       filled because nothing explicitly calls them. They must though, so
+            #       integrations like ActionPack can receive the value as it should.
+            #       Trigger these manually to force an eager load and propagate them.
+            analytics_enabled
+            analytics_sample_rate
+          end
+
           option :analytics_enabled do |o|
             o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, nil) }
             o.lazy
@@ -72,6 +85,7 @@ module Datadog
               Datadog.configuration[:active_support][:tracer] = value
               Datadog.configuration[:action_pack][:tracer] = value
               Datadog.configuration[:action_view][:tracer] = value
+              Datadog.configuration[:rack][:tracer] = value
             end
           end
         end

data/lib/ddtrace/contrib/rails/framework.rb

@@ -21,30 +21,32 @@ module Datadog
       module Framework
         # configure Datadog settings
         def self.setup
-          config = config_with_defaults
-
-          activate_rack!(config)
-          activate_action_cable!(config)
-          activate_active_support!(config)
-          activate_action_pack!(config)
-          activate_action_view!(config)
-          activate_active_record!(config)
-
-          # By default, default service would be guessed from the script
-          # being executed, but here we know better, get it from Rails config.
-          # Don't set this if service has been explicitly provided by the user.
-          Datadog.configuration.service ||= config[:service_name]
-
-          # Set the environment to the Rails environment.
-          # Don't set this if env has been explicitly provided by the user.
-          Datadog.configuration.env ||= ::Rails.env if ::Rails.respond_to?(:env)
+          rails_config = config_with_defaults
+
+          # NOTE: #configure has the side effect of rebuilding trace components.
+          #       During a typical Rails application lifecycle, we will see trace
+          #       components initialized twice because of this. This is necessary
+          #       because key configuration is not available until after the Rails
+          #       application has fully loaded, and some of this configuration is
+          #       used to reconfigure tracer components with Rails-sourced defaults.
+          #       This is a trade-off we take to get nice defaults.
+          Datadog.configure do |datadog_config|
+            # By default, default service would be guessed from the script
+            # being executed, but here we know better, get it from Rails config.
+            # Don't set this if service has been explicitly provided by the user.
+            datadog_config.service ||= rails_config[:service_name]
+
+            activate_rack!(datadog_config, rails_config)
+            activate_action_cable!(datadog_config, rails_config)
+            activate_active_support!(datadog_config, rails_config)
+            activate_action_pack!(datadog_config, rails_config)
+            activate_action_view!(datadog_config, rails_config)
+            activate_active_record!(datadog_config, rails_config)
+          end
 
           # Update the tracer if its not the default tracer.
-          if config[:tracer] != Datadog.configuration.tracer
-            config[:tracer].default_service = config[:service_name]
-
-            env = Datadog.configuration.env || (::Rails.respond_to?(:env) && ::Rails.env)
-            config[:tracer].set_tags('env' => env) if env
+          if rails_config[:tracer] != Datadog.configuration.tracer
+            rails_config[:tracer].default_service = rails_config[:service_name]
           end
         end
 
@@ -59,64 +61,68 @@ module Datadog
           end
         end
 
-        def self.activate_rack!(config)
-          Datadog.configuration.use(
+        def self.activate_rack!(datadog_config, rails_config)
+          datadog_config.use(
             :rack,
-            tracer: config[:tracer],
+            tracer: rails_config[:tracer],
             application: ::Rails.application,
-            service_name: config[:service_name],
-            middleware_names: config[:middleware_names],
-            distributed_tracing: config[:distributed_tracing]
+            service_name: rails_config[:service_name],
+            middleware_names: rails_config[:middleware_names],
+            distributed_tracing: rails_config[:distributed_tracing]
           )
         end
 
-        def self.activate_active_support!(config)
+        def self.activate_active_support!(datadog_config, rails_config)
           return unless defined?(::ActiveSupport)
 
-          Datadog.configuration.use(
+          datadog_config.use(
             :active_support,
-            cache_service: config[:cache_service],
-            tracer: config[:tracer]
+            cache_service: rails_config[:cache_service],
+            tracer: rails_config[:tracer]
           )
         end
 
-        def self.activate_action_cable!(config)
+        def self.activate_action_cable!(datadog_config, rails_config)
           return unless defined?(::ActionCable)
 
-          Datadog.configuration.use(
+          datadog_config.use(
             :action_cable,
-            service_name: "#{config[:service_name]}-#{Contrib::ActionCable::Ext::SERVICE_NAME}",
-            tracer: config[:tracer]
+            service_name: "#{rails_config[:service_name]}-#{Contrib::ActionCable::Ext::SERVICE_NAME}",
+            tracer: rails_config[:tracer]
           )
         end
 
-        def self.activate_action_pack!(config)
+        def self.activate_action_pack!(datadog_config, rails_config)
           return unless defined?(::ActionPack)
 
-          Datadog.configuration.use(
+          # TODO: This is configuring ActionPack but not patching. It will queue ActionPack
+          #       for patching, but patching won't take place until Datadog.configure completes.
+          #       Should we manually patch here?
+
+          datadog_config.use(
             :action_pack,
-            service_name: config[:service_name],
-            tracer: config[:tracer]
+            service_name: rails_config[:service_name],
+            tracer: rails_config[:tracer]
           )
         end
 
-        def self.activate_action_view!(config)
+        def self.activate_action_view!(datadog_config, rails_config)
           return unless defined?(::ActionView)
 
-          Datadog.configuration.use(
+          datadog_config.use(
             :action_view,
-            service_name: config[:service_name],
-            tracer: config[:tracer]
+            service_name: rails_config[:service_name],
+            tracer: rails_config[:tracer]
           )
         end
 
-        def self.activate_active_record!(config)
+        def self.activate_active_record!(datadog_config, rails_config)
           return unless defined?(::ActiveRecord)
 
-          Datadog.configuration.use(
+          datadog_config.use(
             :active_record,
-            service_name: config[:database_service],
-            tracer: config[:tracer]
+            service_name: rails_config[:database_service],
+            tracer: rails_config[:tracer]
           )
         end
       end

data/lib/ddtrace/contrib/rails/integration.rb

@@ -16,7 +16,7 @@ module Datadog
         register_as :rails, auto_patch: false
 
         def self.version
-          Gem.loaded_specs['rails'] && Gem.loaded_specs['rails'].version
+          Gem.loaded_specs['railties'] && Gem.loaded_specs['railties'].version
         end
 
         def self.loaded?

data/lib/ddtrace/contrib/rake/instrumentation.rb

@@ -51,14 +51,14 @@ module Datadog
             span.set_tag(Ext::TAG_TASK_ARG_NAMES, arg_names)
             span.set_tag(Ext::TAG_INVOKE_ARGS, quantize_args(args)) unless args.nil?
           rescue StandardError => e
-            Datadog::Logger.log.debug("Error while tracing Rake invoke: #{e.message}")
+            Datadog.logger.debug("Error while tracing Rake invoke: #{e.message}")
           end
 
           def annotate_execute!(span, args)
             span.resource = name
             span.set_tag(Ext::TAG_EXECUTE_ARGS, quantize_args(args.to_hash)) unless args.nil?
           rescue StandardError => e
-            Datadog::Logger.log.debug("Error while tracing Rake execute: #{e.message}")
+            Datadog.logger.debug("Error while tracing Rake execute: #{e.message}")
           end
 
           def quantize_args(args)

data/lib/ddtrace/contrib/redis/quantize.rb

@@ -15,7 +15,7 @@ module Datadog
           str = Utils.utf8_encode(str, binary: true, placeholder: PLACEHOLDER)
           Utils.truncate(str, VALUE_MAX_LEN, TOO_LONG_MARK)
         rescue => e
-          Datadog::Logger.log.debug("non formattable Redis arg #{str}: #{e}")
+          Datadog.logger.debug("non formattable Redis arg #{str}: #{e}")
           PLACEHOLDER
         end
 

data/lib/ddtrace/contrib/resque/resque_job.rb

@@ -9,11 +9,11 @@ module Datadog
     module Resque
       # Uses Resque job hooks to create traces
       module ResqueJob
-        def around_perform(*_)
+        def around_perform(*args)
           return yield unless datadog_configuration && tracer
 
           tracer.trace(Ext::SPAN_JOB, span_options) do |span|
-            span.resource = name
+            span.resource = args.first.is_a?(Hash) && args.first['job_class'] || name
             span.span_type = Datadog::Ext::AppTypes::WORKER
             # Set analytics sample rate
             if Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])

data/lib/ddtrace/contrib/sidekiq/tracing.rb

@@ -26,7 +26,7 @@ module Datadog
             job['class'].to_s
           end
         rescue => e
-          Datadog::Logger.log.debug { "Error retrieving Sidekiq job class name (jid:#{job['jid']}): #{e}" }
+          Datadog.logger.debug { "Error retrieving Sidekiq job class name (jid:#{job['jid']}): #{e}" }
 
           job['class'].to_s
         end

data/lib/ddtrace/contrib/sinatra/env.rb

@@ -32,6 +32,26 @@ module Datadog
         def header_to_rack_header(name)
           "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
         end
+
+        # Was a Sinatra already traced in this request?
+        # We don't want to create spans for intermediate Sinatra
+        # middlewares that don't match the request at hand.
+        def middleware_traced?(env)
+          env[Ext::RACK_ENV_MIDDLEWARE_TRACED]
+        end
+
+        def set_middleware_traced(env, bool)
+          env[Ext::RACK_ENV_MIDDLEWARE_TRACED] = bool
+        end
+
+        # The start time of the top-most Sinatra middleware.
+        def middleware_start_time(env)
+          env[Ext::RACK_ENV_MIDDLEWARE_START_TIME]
+        end
+
+        def set_middleware_start_time(env, time = Time.now.utc)
+          env[Ext::RACK_ENV_MIDDLEWARE_START_TIME] = time
+        end
       end
     end
   end

data/lib/ddtrace/contrib/sinatra/ext.rb

@@ -7,10 +7,16 @@ module Datadog
         ENV_ANALYTICS_ENABLED = 'DD_SINATRA_ANALYTICS_ENABLED'.freeze
         ENV_ANALYTICS_SAMPLE_RATE = 'DD_SINATRA_ANALYTICS_SAMPLE_RATE'.freeze
         RACK_ENV_REQUEST_SPAN = 'datadog.sinatra_request_span'.freeze
+        RACK_ENV_MIDDLEWARE_START_TIME = 'datadog.sinatra_middleware_start_time'.freeze
+        RACK_ENV_MIDDLEWARE_TRACED = 'datadog.sinatra_middleware_traced'.freeze
         SERVICE_NAME = 'sinatra'.freeze
         SPAN_RENDER_TEMPLATE = 'sinatra.render_template'.freeze
         SPAN_REQUEST = 'sinatra.request'.freeze
+        SPAN_ROUTE = 'sinatra.route'.freeze
+        TAG_APP_NAME = 'sinatra.app.name'.freeze
         TAG_ROUTE_PATH = 'sinatra.route.path'.freeze
+        TAG_SCRIPT_NAME = 'sinatra.script_name'.freeze
+        TAG_TEMPLATE_ENGINE = 'sinatra.template_engine'.freeze
         TAG_TEMPLATE_NAME = 'sinatra.template_name'.freeze
       end
     end

data/lib/ddtrace/contrib/sinatra/patcher.rb

@@ -20,6 +20,7 @@ module Datadog
 
         def register_tracer
           ::Sinatra.send(:register, Datadog::Contrib::Sinatra::Tracer)
+          ::Sinatra::Base.send(:prepend, Sinatra::Tracer::Base)
         end
       end
     end

data/lib/ddtrace/contrib/sinatra/tracer.rb

@@ -21,6 +21,10 @@ module Datadog
           condition do
             # If the option to prepend script names is enabled, then
             # prepend the script name from the request onto the action.
+            #
+            # DEV: env['sinatra.route'] already exists with very similar information,
+            # DEV: but doesn't account for our `resource_script_names` logic.
+            #
             @datadog_route = if Datadog.configuration[:sinatra][:resource_script_names]
                                "#{request.script_name}#{action}"
                              else
@@ -32,53 +36,112 @@ module Datadog
         end
 
         def self.registered(app)
-          ::Sinatra::Base.module_eval do
-            def render(engine, data, *)
-              output = ''
-              tracer = Datadog.configuration[:sinatra][:tracer]
-              if tracer.enabled
-                tracer.trace(Ext::SPAN_RENDER_TEMPLATE, span_type: Datadog::Ext::HTTP::TEMPLATE) do |span|
-                  # If data is a string, it is a literal template and we don't
-                  # want to record it.
-                  span.set_tag(Ext::TAG_TEMPLATE_NAME, data) if data.is_a? Symbol
-
-                  # Measure service stats
-                  Contrib::Analytics.set_measured(span)
-
-                  output = super
-                end
-              else
-                output = super
-              end
+          app.use TracerMiddleware
 
-              output
-            end
-          end
+          app.after do
+            configuration = Datadog.configuration[:sinatra]
+            next unless configuration[:tracer].enabled
 
-          app.use TracerMiddleware
+            # Ensures we only create a span for the top-most Sinatra middleware.
+            #
+            # If we traced all Sinatra middleware apps, we would have a chain
+            # of nested spans that were not responsible for handling this request,
+            # adding little value to users.
+            next if Sinatra::Env.middleware_traced?(env)
+
+            span = Sinatra::Env.datadog_span(env) || Sinatra::Tracer.create_middleware_span(env, configuration)
+
+            route = if defined?(@datadog_route)
+                      @datadog_route
+                    else
+                      # Fallback in case no routes have matched
+                      request.path
+                    end
 
-          app.before do
-            return unless Datadog.configuration[:sinatra][:tracer].enabled
+            span.resource = "#{request.request_method} #{route}"
 
-            span = Sinatra::Env.datadog_span(env)
             span.set_tag(Datadog::Ext::HTTP::URL, request.path)
             span.set_tag(Datadog::Ext::HTTP::METHOD, request.request_method)
+            span.set_tag(Ext::TAG_APP_NAME, app.settings.name)
+            span.set_tag(Ext::TAG_ROUTE_PATH, route)
+            if request.script_name && !request.script_name.empty?
+              span.set_tag(Ext::TAG_SCRIPT_NAME, request.script_name)
+            end
+
+            span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
+            span.set_error(env['sinatra.error']) if response.server_error?
+
+            Sinatra::Env.set_middleware_traced(env, true)
           end
+        end
 
-          app.after do
-            return unless Datadog.configuration[:sinatra][:tracer].enabled
+        # Initializes a span for the top-most Sinatra middleware.
+        def self.create_middleware_span(env, configuration)
+          tracer = configuration[:tracer]
+          span = tracer.trace(
+            Ext::SPAN_REQUEST,
+            service: configuration[:service_name],
+            span_type: Datadog::Ext::HTTP::TYPE_INBOUND,
+            start_time: Sinatra::Env.middleware_start_time(env)
+          )
+
+          Sinatra::Env.set_datadog_span(env, span)
+          span
+        end
+
+        # Method overrides for Sinatra::Base
+        module Base
+          def render(engine, data, *)
+            tracer = Datadog.configuration[:sinatra][:tracer]
+            return super unless tracer.enabled
+
+            tracer.trace(Ext::SPAN_RENDER_TEMPLATE, span_type: Datadog::Ext::HTTP::TEMPLATE) do |span|
+              span.set_tag(Ext::TAG_TEMPLATE_ENGINE, engine)
+
+              # If data is a string, it is a literal template and we don't
+              # want to record it.
+              span.set_tag(Ext::TAG_TEMPLATE_NAME, data) if data.is_a? Symbol
 
-            span = Sinatra::Env.datadog_span(env)
+              # Measure service stats
+              Contrib::Analytics.set_measured(span)
 
-            unless span
-              Datadog::Logger.log.error('missing request span in :after hook')
-              return
+              super
             end
+          end
 
-            span.resource = "#{request.request_method} #{@datadog_route}"
-            span.set_tag(Ext::TAG_ROUTE_PATH, @datadog_route)
-            span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
-            span.set_error(env['sinatra.error']) if response.server_error?
+          # Invoked when a matching route is found.
+          # This method yields directly to user code.
+          def route_eval
+            configuration = Datadog.configuration[:sinatra]
+            tracer = configuration[:tracer]
+
+            return super unless tracer.enabled
+
+            # For initialization of Sinatra middleware span in order
+            # guarantee that the Ext::SPAN_ROUTE span being created below
+            # has the middleware span as its parent.
+            Sinatra::Tracer.create_middleware_span(env, configuration) unless Sinatra::Env.datadog_span(env)
+
+            tracer.trace(
+              Ext::SPAN_ROUTE,
+              service: configuration[:service_name],
+              span_type: Datadog::Ext::HTTP::TYPE_INBOUND
+            ) do |span|
+              span.resource = "#{request.request_method} #{@datadog_route}"
+
+              span.set_tag(Ext::TAG_APP_NAME, settings.name || settings.superclass.name)
+              span.set_tag(Ext::TAG_ROUTE_PATH, @datadog_route)
+              if request.script_name && !request.script_name.empty?
+                span.set_tag(Ext::TAG_SCRIPT_NAME, request.script_name)
+              end
+
+              rack_request_span = env[Datadog::Contrib::Rack::TraceMiddleware::RACK_REQUEST_SPAN]
+              rack_request_span.resource = span.resource if rack_request_span
+
+              Contrib::Analytics.set_measured(span)
+
+              super
+            end
           end
         end
       end