ddtrace 1.4.2 → 1.23.3

data/lib/datadog/tracing/contrib/sidekiq/server_internal_tracer/heartbeat.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Tracing
@@ -7,14 +7,18 @@ module Datadog
         module ServerInternalTracer
           # Trace when a Sidekiq process has a heartbeat
           module Heartbeat
-            def stop
+            private
+
+            def heartbeat
               configuration = Datadog.configuration.tracing[:sidekiq]
 
-              Datadog::Tracing.trace(Ext::SPAN_STOP, service: configuration[:service_name]) do |span|
+              Datadog::Tracing.trace(Ext::SPAN_HEARTBEAT, service: configuration[:service_name]) do |span|
                 span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
 
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
                 span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
-                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_STOP)
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_HEARTBEAT)
 
                 # Set analytics sample rate
                 if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
@@ -24,15 +28,20 @@ module Datadog
                 super
               end
             end
+          end
 
+          # This implementation is identical to `Heartbeat`, but patching `beat` method instead.
+          module Beat
             private
 
-            def heartbeat
+            def beat
               configuration = Datadog.configuration.tracing[:sidekiq]
 
               Datadog::Tracing.trace(Ext::SPAN_HEARTBEAT, service: configuration[:service_name]) do |span|
                 span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
 
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
                 span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
                 span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_HEARTBEAT)
 

data/lib/datadog/tracing/contrib/sidekiq/server_internal_tracer/job_fetch.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Tracing
@@ -15,6 +15,8 @@ module Datadog
               Datadog::Tracing.trace(Ext::SPAN_JOB_FETCH, service: configuration[:service_name]) do |span|
                 span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
 
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
                 span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
                 span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_JOB_FETCH)
 

data/lib/datadog/tracing/contrib/sidekiq/server_internal_tracer/redis_info.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Tracing
@@ -13,6 +13,8 @@ module Datadog
               Datadog::Tracing.trace(Ext::SPAN_REDIS_INFO, service: configuration[:service_name]) do |span|
                 span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
 
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
                 span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
                 span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REDIS_INFO)
 

data/lib/datadog/tracing/contrib/sidekiq/server_internal_tracer/scheduled_poller.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Tracing
@@ -14,6 +14,8 @@ module Datadog
               Datadog::Tracing.trace(Ext::SPAN_SCHEDULED_PUSH, service: configuration[:service_name]) do |span|
                 span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
 
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
                 span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
                 span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_SCHEDULED_PUSH)
 
@@ -34,6 +36,8 @@ module Datadog
               Datadog::Tracing.trace(Ext::SPAN_SCHEDULED_WAIT, service: configuration[:service_name]) do |span|
                 span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
 
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
                 span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
                 span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_SCHEDULED_WAIT)
 

data/lib/datadog/tracing/contrib/sidekiq/server_internal_tracer/stop.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        module ServerInternalTracer
+          # Trace when Sidekiq stops
+          module Stop
+            def stop
+              configuration = Datadog.configuration.tracing[:sidekiq]
+
+              Datadog::Tracing.trace(Ext::SPAN_STOP, service: configuration[:service_name]) do |span|
+                span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_STOP)
+
+                # Set analytics sample rate
+                if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                  Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+                end
+
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sidekiq/server_tracer.rb

@@ -1,10 +1,11 @@
-# typed: true
+# frozen_string_literal: true
 
 require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative 'ext'
-require_relative 'tracing'
+require_relative 'utils'
 require_relative '../utils/quantization/hash'
+require_relative 'distributed/propagation'
 
 module Datadog
   module Tracing
@@ -12,7 +13,7 @@ module Datadog
       module Sidekiq
         # Tracer is a Sidekiq server-side middleware which traces executed jobs
         class ServerTracer
-          include Tracing
+          include Utils
 
           QUANTIZE_SHOW_ALL = { args: { show: :all } }.freeze
 
@@ -21,9 +22,16 @@ module Datadog
             @error_handler = options[:error_handler] || configuration[:error_handler]
           end
 
+          # rubocop:disable Metrics/MethodLength
+          # rubocop:disable Metrics/AbcSize
           def call(worker, job, queue)
             resource = job_resource(job)
 
+            if configuration[:distributed_tracing]
+              trace_digest = propagation.extract(job)
+              Datadog::Tracing.continue_trace!(trace_digest)
+            end
+
             service = worker_config(resource, :service_name) || @sidekiq_service
             # DEV-2.0: Remove `tag_args`, as `quantize` can fulfill the same contract
             tag_args = worker_config(resource, :tag_args) || configuration[:tag_args]
@@ -37,9 +45,16 @@ module Datadog
             ) do |span|
               span.resource = resource
 
+              span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
               span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_JOB)
 
+              span.set_tag(
+                Datadog::Tracing::Metadata::Ext::TAG_KIND,
+                Datadog::Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER
+              )
+
               # Set analytics sample rate
               if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
                 Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
@@ -63,10 +78,16 @@ module Datadog
 
               yield
             end
+            # rubocop:enable Metrics/MethodLength
+            # rubocop:enable Metrics/AbcSize
           end
 
           private
 
+          def propagation
+            @propagation ||= Contrib::Sidekiq::Distributed::Propagation.new
+          end
+
           def quantize_args(quantize, args)
             quantize_options = quantize && quantize[:args]
             quantize_options ||= {}

data/lib/datadog/tracing/contrib/sidekiq/{tracing.rb → utils.rb}

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 require 'yaml'
 
@@ -10,7 +10,7 @@ module Datadog
     module Contrib
       module Sidekiq
         # Common functionality used by both client-side and server-side tracers.
-        module Tracing
+        module Utils
           protected
 
           # If class is wrapping something else, the interesting resource info

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

@@ -1,5 +1,3 @@
-# typed: false
-
 require_relative '../../configuration/settings'
 require_relative '../ext'
 
@@ -16,23 +14,26 @@ 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
 
+            # @!visibility private
             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 :distributed_tracing, default: true
-            option :headers, default: DEFAULT_HEADERS
-            option :resource_script_names, default: false
+            option :distributed_tracing, default: true, type: :bool
+            option :headers, default: DEFAULT_HEADERS, type: :hash
+            option :resource_script_names, default: false, type: :bool
 
             option :service_name
           end

data/lib/datadog/tracing/contrib/sinatra/env.rb

@@ -1,5 +1,3 @@
-# typed: true
-
 require 'time'
 
 require_relative '../../metadata/ext'
@@ -13,52 +11,24 @@ module Datadog
         module Env
           module_function
 
-          def datadog_span(env, app)
-            request_span = env[Ext::RACK_ENV_REQUEST_SPAN]
-            request_span && request_span[app]
+          def datadog_span(env)
+            env[Ext::RACK_ENV_SINATRA_REQUEST_SPAN]
           end
 
-          def set_datadog_span(env, app, span)
-            hash = (env[Ext::RACK_ENV_REQUEST_SPAN] ||= {})
-            hash[app] = span
+          def set_datadog_span(env, span)
+            env[Ext::RACK_ENV_SINATRA_REQUEST_SPAN] = span
           end
 
-          def request_header_tags(env, headers)
-            headers ||= []
+          def route_path(env, use_script_names: Datadog.configuration.tracing[:sinatra][:resource_script_names])
+            return unless env['sinatra.route']
 
-            {}.tap do |result|
-              headers.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
+            _, path = env['sinatra.route'].split(' ', 2)
+            if use_script_names
+              env['SCRIPT_NAME'].to_s + path
+            else
+              path
             end
           end
-
-          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/datadog/tracing/contrib/sinatra/ext.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Tracing
@@ -7,24 +7,29 @@ module Datadog
         # Sinatra integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_SINATRA_ENABLED'.freeze
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_SINATRA_ANALYTICS_ENABLED'.freeze
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_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
-          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_COMPONENT = 'sinatra'.freeze
-          TAG_OPERATION_RENDER_TEMPLATE = 'render_template'.freeze
-          TAG_OPERATION_REQUEST = 'request'.freeze
-          TAG_OPERATION_ROUTE = 'route'.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
+          ENV_ENABLED = 'DD_TRACE_SINATRA_ENABLED'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_SINATRA_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SINATRA_ANALYTICS_SAMPLE_RATE'
+          RACK_ENV_SINATRA_REQUEST_SPAN = 'datadog.sinatra_request_span'
+          SPAN_RENDER_TEMPLATE = 'sinatra.render_template'
+          SPAN_REQUEST = 'sinatra.request'
+          SPAN_ROUTE = 'sinatra.route'
+          TAG_APP_NAME = 'sinatra.app.name'
+          TAG_COMPONENT = 'sinatra'
+          TAG_OPERATION_RENDER_TEMPLATE = 'render_template'
+          TAG_OPERATION_REQUEST = 'request'
+          TAG_OPERATION_ROUTE = 'route'
+          TAG_ROUTE_PATH = 'sinatra.route.path'
+          TAG_SCRIPT_NAME = 'sinatra.script_name'
+          TAG_TEMPLATE_ENGINE = 'sinatra.template_engine'
+          TAG_TEMPLATE_NAME = 'sinatra.template_name'
+
+          # === Deprecated: To be removed ===
+          RACK_ENV_REQUEST_SPAN = 'datadog.sinatra_request_span'
+          RACK_ENV_MIDDLEWARE_START_TIME = 'datadog.sinatra_middleware_start_time'
+          RACK_ENV_MIDDLEWARE_TRACED = 'datadog.sinatra_middleware_traced'
+          # === Deprecated: To be removed ===
         end
       end
     end

data/lib/datadog/tracing/contrib/sinatra/framework.rb

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

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

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

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

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 require_relative '../../../core/utils/only_once'
 require_relative '../patcher'
@@ -40,7 +40,6 @@ module Datadog
 
         # Patcher enables patching of 'sinatra' module.
         module Patcher
-          include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
           include Contrib::Patcher
 
           module_function
@@ -58,7 +57,7 @@ module Datadog
           end
 
           def register_tracer
-            ::Sinatra.send(:register, Contrib::Sinatra::Tracer)
+            ::Sinatra::Base.register(Contrib::Sinatra::Tracer)
             ::Sinatra::Base.prepend(Sinatra::Tracer::Base)
           end
 

data/lib/datadog/tracing/contrib/sinatra/tracer.rb

@@ -1,5 +1,3 @@
-# typed: false
-
 require 'sinatra/base'
 
 require_relative '../../../core/utils/only_once'
@@ -17,69 +15,12 @@ module Datadog
         # Datadog::Tracing::Contrib::Sinatra::Tracer is a Sinatra extension which traces
         # requests.
         module Tracer
-          def route(verb, action, *)
-            # Keep track of the route name when the app is instantiated for an
-            # incoming request.
-            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.tracing[:sinatra][:resource_script_names]
-                                 "#{request.script_name}#{action}"
-                               else
-                                 action
-                               end
-            end
-
-            super
-          end
-
           def self.registered(app)
             app.use TracerMiddleware, app_instance: app
-
-            app.after do
-              next unless Tracing.enabled?
-
-              span = Sinatra::Env.datadog_span(env, app)
-
-              # TODO: `route` should *only* be populated if @datadog_route is defined.
-              # TODO: If @datadog_route is not defined, then this Sinatra app is not responsible
-              # TODO: for handling this request.
-              # TODO:
-              # TODO: This change would be BREAKING for any Sinatra app (classic or modular),
-              # TODO: as it affects the `resource` value for requests not handled by the Sinatra app.
-              # TODO: Currently we use "#{method} #{path}" in such aces, but `path` is the raw,
-              # TODO: high-cardinality HTTP path, and can contain PII.
-              # TODO:
-              # TODO: The value we should use as the `resource` when the Sinatra app is not
-              # TODO: responsible for the request is a tricky subject.
-              # TODO: The best option is a value that clearly communicates that this app did not
-              # TODO: handle this request. It's important to keep in mind that an unhandled request
-              # TODO: by this Sinatra app might still be handled by another Rack middleware (which can
-              # TODO: be a Sinatra app itself) or it might just 404 if not handled at all.
-              # TODO:
-              # TODO: A possible value for `resource` could set a high level description, e.g.
-              # TODO: `request.request_method`, given we don't have the response object available yet.
-              route = if defined?(@datadog_route)
-                        @datadog_route
-                      else
-                        # Fallback in case no routes have matched
-                        request.path
-                      end
-
-              span.resource = "#{request.request_method} #{route}"
-              span.set_tag(Ext::TAG_ROUTE_PATH, route)
-            end
           end
 
           # Method overrides for Sinatra::Base
           module Base
-            MISSING_REQUEST_SPAN_ONLY_ONCE = Core::Utils::OnlyOnce.new
-            private_constant :MISSING_REQUEST_SPAN_ONLY_ONCE
-
             def render(engine, data, *)
               return super unless Tracing.enabled?
 
@@ -102,19 +43,21 @@ module Datadog
 
             # Invoked when a matching route is found.
             # This method yields directly to user code.
-            # rubocop:disable Metrics/MethodLength
             def route_eval
               configuration = Datadog.configuration.tracing[:sinatra]
               return super unless Tracing.enabled?
 
+              datadog_route = Sinatra::Env.route_path(env)
+
               Tracing.trace(
                 Ext::SPAN_ROUTE,
                 service: configuration[:service_name],
                 span_type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND,
-                resource: "#{request.request_method} #{@datadog_route}",
+                resource: "#{request.request_method} #{datadog_route}",
               ) do |span, trace|
                 span.set_tag(Ext::TAG_APP_NAME, settings.name || settings.superclass.name)
-                span.set_tag(Ext::TAG_ROUTE_PATH, @datadog_route)
+                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
@@ -124,32 +67,15 @@ module Datadog
 
                 trace.resource = span.resource
 
-                sinatra_request_span =
-                  if self.class <= ::Sinatra::Application # Classic style (top-level) application
-                    Sinatra::Env.datadog_span(env, ::Sinatra::Application)
-                  else
-                    Sinatra::Env.datadog_span(env, self.class)
-                  end
-                if sinatra_request_span
-                  sinatra_request_span.resource = span.resource
-                else
-                  MISSING_REQUEST_SPAN_ONLY_ONCE.run do
-                    Datadog.logger.warn do
-                      'Sinatra integration is misconfigured, reported traces will be missing request metadata ' \
-                      'such as path and HTTP status code. ' \
-                      'Did you forget to add `register Datadog::Tracing::Contrib::Sinatra::Tracer` to your ' \
-                      '`Sinatra::Base` subclass? ' \
-                      'See <https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#sinatra> for more details.'
-                    end
-                  end
-                end
+                sinatra_request_span = Sinatra::Env.datadog_span(env)
+
+                sinatra_request_span.resource = span.resource
 
                 Contrib::Analytics.set_measured(span)
 
                 super
               end
             end
-            # rubocop:enable Metrics/MethodLength
           end
         end
       end

data/lib/datadog/tracing/contrib/sinatra/tracer_middleware.rb

@@ -1,11 +1,11 @@
-# typed: false
+# frozen_string_literal: true
 
 require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative '../rack/ext'
+require_relative '../rack/header_tagging'
 require_relative 'env'
 require_relative 'ext'
-require_relative 'headers'
 
 module Datadog
   module Tracing
@@ -20,15 +20,15 @@ module Datadog
 
           # rubocop:disable Metrics/AbcSize
           # rubocop:disable Metrics/MethodLength
-          # rubocop:disable Metrics/CyclomaticComplexity
-          # rubocop:disable Metrics/PerceivedComplexity
           def call(env)
             # Set the trace context (e.g. distributed tracing)
             if configuration[:distributed_tracing] && Tracing.active_trace.nil?
-              original_trace = Propagation::HTTP.extract(env)
+              original_trace = Tracing::Propagation::HTTP.extract(env)
               Tracing.continue_trace!(original_trace)
             end
 
+            return @app.call(env) if Sinatra::Env.datadog_span(env)
+
             Tracing.trace(
               Ext::SPAN_REQUEST,
               service: configuration[:service_name],
@@ -39,26 +39,28 @@ module Datadog
                 # the nil signals that there's no good one yet and is also seen by profiler, when sampling the resource
                 span.resource = nil
 
-                Sinatra::Env.set_datadog_span(env, @app_instance, span)
+                Sinatra::Env.set_datadog_span(env, span)
 
                 response = @app.call(env)
               ensure
-                Sinatra::Env.request_header_tags(env, configuration[:headers][:request]).each do |name, value|
-                  span.set_tag(name, value) if span.get_tag(name).nil?
-                end
+                Contrib::Rack::HeaderTagging.tag_request_headers(span, env, configuration)
 
                 span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
                 span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
 
                 request = ::Sinatra::Request.new(env)
+
                 span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, request.path)
                 span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, request.request_method)
+
+                datadog_route = Sinatra::Env.route_path(env)
+
+                span.set_tag(Ext::TAG_ROUTE_PATH, datadog_route) if datadog_route
+
                 if request.script_name && !request.script_name.empty?
                   span.set_tag(Ext::TAG_SCRIPT_NAME, request.script_name)
                 end
 
-                span.set_tag(Ext::TAG_APP_NAME, @app_instance.settings.name)
-
                 # If this app handled the request, then Contrib::Sinatra::Tracer OR Contrib::Sinatra::Base set the
                 # resource; if no resource was set, let's use a fallback
                 span.resource = env['REQUEST_METHOD'] if span.resource.nil?
@@ -79,9 +81,7 @@ module Datadog
                   end
 
                   if (headers = response[1])
-                    Sinatra::Headers.response_header_tags(headers, configuration[:headers][:response]).each do |name, value|
-                      span.set_tag(name, value) if span.get_tag(name).nil?
-                    end
+                    Contrib::Rack::HeaderTagging.tag_response_headers(span, headers, configuration)
                   end
                 end
 
@@ -95,8 +95,6 @@ module Datadog
           end
           # rubocop:enable Metrics/AbcSize
           # rubocop:enable Metrics/MethodLength
-          # rubocop:enable Metrics/CyclomaticComplexity
-          # rubocop:enable Metrics/PerceivedComplexity
 
           private
 
@@ -111,10 +109,6 @@ module Datadog
           def configuration
             Datadog.configuration.tracing[:sinatra]
           end
-
-          def header_to_rack_header(name)
-            "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
-          end
         end
       end
     end