ddtrace 1.0.0 → 1.10.1

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

@@ -0,0 +1,55 @@
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        module ServerInternalTracer
+          # Trace when Sidekiq checks to see if there are scheduled jobs that need to be worked
+          # https://github.com/mperham/sidekiq/wiki/Scheduled-Jobs
+          module ScheduledPoller
+            def enqueue
+              configuration = Datadog.configuration.tracing[:sidekiq]
+
+              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)
+
+                # 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
+
+            private
+
+            def wait
+              configuration = Datadog.configuration.tracing[:sidekiq]
+
+              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)
+
+                # 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,8 @@
-# typed: true
-
-require 'datadog/tracing'
-require 'datadog/tracing/metadata/ext'
-require 'datadog/tracing/contrib/analytics'
-require 'datadog/tracing/contrib/sidekiq/ext'
-require 'datadog/tracing/contrib/sidekiq/tracing'
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative 'ext'
+require_relative 'tracing'
+require_relative '../utils/quantization/hash'
 
 module Datadog
   module Tracing
@@ -14,6 +12,8 @@ module Datadog
         class ServerTracer
           include Tracing
 
+          QUANTIZE_SHOW_ALL = { args: { show: :all } }.freeze
+
           def initialize(options = {})
             @sidekiq_service = options[:service_name] || configuration[:service_name]
             @error_handler = options[:error_handler] || configuration[:error_handler]
@@ -23,7 +23,9 @@ module Datadog
             resource = job_resource(job)
 
             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]
+            quantize = worker_config(resource, :quantize) || configuration[:quantize]
 
             Datadog::Tracing.trace(
               Ext::SPAN_JOB,
@@ -33,9 +35,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])
@@ -50,7 +59,12 @@ module Datadog
               span.set_tag(Ext::TAG_JOB_QUEUE, job['queue'])
               span.set_tag(Ext::TAG_JOB_WRAPPER, job['class']) if job['wrapped']
               span.set_tag(Ext::TAG_JOB_DELAY, 1000.0 * (Time.now.utc.to_f - job['enqueued_at'].to_f))
-              span.set_tag(Ext::TAG_JOB_ARGS, job['args']) if tag_args && !job['args'].nil? && !job['args'].empty?
+
+              args = job['args']
+              if args && !args.empty?
+                quantize = tag_args ? QUANTIZE_SHOW_ALL : quantize
+                span.set_tag(Ext::TAG_JOB_ARGS, quantize_args(quantize, args))
+              end
 
               yield
             end
@@ -58,10 +72,19 @@ module Datadog
 
           private
 
+          def quantize_args(quantize, args)
+            quantize_options = quantize && quantize[:args]
+            quantize_options ||= {}
+
+            Contrib::Utils::Quantization::Hash.format(args, quantize_options)
+          end
+
           def configuration
             Datadog.configuration.tracing[:sidekiq]
           end
 
+          # DEV-2.0: Is this still being used? If not, we should remove it
+          # as this adds brittleness and complexity to this integration.
           def worker_config(resource, key)
             # Try to get the Ruby class from the resource name.
             worker_klass = begin

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

@@ -1,9 +1,7 @@
-# typed: true
-
 require 'yaml'
 
-require 'datadog/core'
-require 'datadog/tracing/contrib/sidekiq/ext'
+require_relative '../../../core'
+require_relative 'ext'
 
 module Datadog
   module Tracing

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

@@ -1,7 +1,5 @@
-# typed: false
-
-require 'datadog/tracing/contrib/configuration/settings'
-require 'datadog/tracing/contrib/sinatra/ext'
+require_relative '../../configuration/settings'
+require_relative '../ext'
 
 module Datadog
   module Tracing

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

@@ -1,9 +1,7 @@
-# typed: true
-
 require 'time'
 
-require 'datadog/tracing/metadata/ext'
-require 'datadog/tracing/contrib/sinatra/ext'
+require_relative '../../metadata/ext'
+require_relative 'ext'
 
 module Datadog
   module Tracing
@@ -13,14 +11,12 @@ 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)
@@ -40,24 +36,15 @@ module Datadog
             "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
+          def route_path(env, use_script_names: Datadog.configuration.tracing[:sinatra][:resource_script_names])
+            return unless env['sinatra.route']
 
-          # 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
+            _, path = env['sinatra.route'].split(' ', 2)
+            if use_script_names
+              env['SCRIPT_NAME'].to_s + path
+            else
+              path
+            end
           end
         end
       end

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

@@ -1,5 +1,3 @@
-# typed: true
-
 module Datadog
   module Tracing
     module Contrib
@@ -10,9 +8,7 @@ module Datadog
           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
+          RACK_ENV_SINATRA_REQUEST_SPAN = 'datadog.sinatra_request_span'.freeze
           SPAN_RENDER_TEMPLATE = 'sinatra.render_template'.freeze
           SPAN_REQUEST = 'sinatra.request'.freeze
           SPAN_ROUTE = 'sinatra.route'.freeze
@@ -25,6 +21,12 @@ module Datadog
           TAG_SCRIPT_NAME = 'sinatra.script_name'.freeze
           TAG_TEMPLATE_ENGINE = 'sinatra.template_engine'.freeze
           TAG_TEMPLATE_NAME = 'sinatra.template_name'.freeze
+
+          # === Deprecated: To be removed ===
+          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
+          # === Deprecated: To be removed ===
         end
       end
     end

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

@@ -1,7 +1,3 @@
-# typed: false
-
-require 'datadog/tracing'
-
 module Datadog
   module Tracing
     module Contrib
@@ -39,6 +35,17 @@ module Datadog
             end
           end
 
+          class << self
+            alias_method :unshift_middleare, :add_middleware
+          end
+
+          # Add Rack middleware at the top of the stack
+          def self.append_middleware(middleware, builder, *args, &block)
+            insert_middleware(builder, middleware, args, block) do |proc_, use|
+              use.append(proc_)
+            end
+          end
+
           # Add Rack middleware before another in the stack
           def self.add_middleware_before(before, middleware, builder, *args, &block)
             index = middlewares(builder).index(before)

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

@@ -1,6 +1,4 @@
-# typed: true
-
-require 'datadog/tracing/metadata/ext'
+require_relative '../../metadata/ext'
 
 module Datadog
   module Tracing

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

@@ -1,8 +1,6 @@
-# typed: false
-
-require 'datadog/tracing/contrib/integration'
-require 'datadog/tracing/contrib/sinatra/configuration/settings'
-require 'datadog/tracing/contrib/sinatra/patcher'
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
 
 module Datadog
   module Tracing

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

@@ -1,10 +1,7 @@
-# typed: true
-
-require 'datadog/core/utils/only_once'
-require 'datadog/tracing/contrib/patcher'
-require 'datadog/tracing/contrib/rack/middlewares'
-require 'datadog/tracing/contrib/sinatra/framework'
-require 'datadog/tracing/contrib/sinatra/integration'
+require_relative '../../../core/utils/only_once'
+require_relative '../patcher'
+require_relative '../rack/middlewares'
+require_relative 'framework'
 
 module Datadog
   module Tracing
@@ -41,7 +38,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
@@ -51,7 +47,7 @@ module Datadog
           end
 
           def patch
-            require 'datadog/tracing/contrib/sinatra/tracer'
+            require_relative 'tracer'
             register_tracer
 
             patch_default_middlewares
@@ -59,7 +55,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,15 +1,12 @@
-# typed: false
-
 require 'sinatra/base'
 
-require 'datadog/core/utils/only_once'
-require 'datadog/tracing'
-require 'datadog/tracing/metadata/ext'
-require 'datadog/tracing/propagation/http'
-require 'datadog/tracing/contrib/analytics'
-require 'datadog/tracing/contrib/sinatra/env'
-require 'datadog/tracing/contrib/sinatra/ext'
-require 'datadog/tracing/contrib/sinatra/tracer_middleware'
+require_relative '../../../core/utils/only_once'
+require_relative '../../metadata/ext'
+require_relative '../../propagation/http'
+require_relative '../analytics'
+require_relative 'env'
+require_relative 'ext'
+require_relative 'tracer_middleware'
 
 module Datadog
   module Tracing
@@ -18,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?
 
@@ -103,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
@@ -125,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,12 +1,9 @@
-# typed: false
-
-require 'datadog/tracing'
-require 'datadog/tracing/metadata/ext'
-require 'datadog/tracing/contrib/analytics'
-require 'datadog/tracing/contrib/rack/ext'
-require 'datadog/tracing/contrib/sinatra/env'
-require 'datadog/tracing/contrib/sinatra/ext'
-require 'datadog/tracing/contrib/sinatra/headers'
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative '../rack/ext'
+require_relative 'env'
+require_relative 'ext'
+require_relative 'headers'
 
 module Datadog
   module Tracing
@@ -26,10 +23,12 @@ module Datadog
           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],
@@ -40,7 +39,7 @@ 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
@@ -52,14 +51,18 @@ module Datadog
                 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?
@@ -80,7 +83,10 @@ module Datadog
                   end
 
                   if (headers = response[1])
-                    Sinatra::Headers.response_header_tags(headers, configuration[:headers][:response]).each do |name, value|
+                    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
                   end
@@ -112,10 +118,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

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

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-# typed: false
-
-require 'datadog/tracing/span_operation'
-require 'datadog/tracing/contrib/configuration/settings'
+require_relative '../../../span_operation'
+require_relative '../../configuration/settings'
 
 module Datadog
   module Tracing

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# typed: strict
-
 module Datadog
   module Tracing
     module Contrib
@@ -19,6 +17,7 @@ module Datadog
           TAG_JOB_BODY = 'sneakers.body'
           TAG_COMPONENT = 'sneakers'
           TAG_OPERATION_JOB = 'job'
+          TAG_MESSAGING_SYSTEM = 'rabbitmq'
         end
       end
     end

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

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-# typed: false
-
-require 'datadog/tracing/contrib/integration'
-require 'datadog/tracing/contrib/sneakers/ext'
-require 'datadog/tracing/contrib/sneakers/configuration/settings'
-require 'datadog/tracing/contrib/sneakers/patcher'
+require_relative '../integration'
+require_relative 'ext'
+require_relative 'configuration/settings'
+require_relative 'patcher'
 
 module Datadog
   module Tracing

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

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-# typed: false
-
-require 'datadog/tracing/contrib/patcher'
-require 'datadog/tracing/contrib/sneakers/integration'
-require 'datadog/tracing/contrib/sneakers/tracer'
+require_relative '../patcher'
+require_relative 'tracer'
 
 module Datadog
   module Tracing