ddtrace 1.0.0 → 1.9.0

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

@@ -1,6 +1,6 @@
 # typed: false
 
-require 'datadog/tracing/contrib/patcher'
+require_relative '../patcher'
 
 module Datadog
   module Tracing
@@ -17,8 +17,8 @@ module Datadog
           end
 
           def patch
-            require 'datadog/tracing/contrib/sidekiq/client_tracer'
-            require 'datadog/tracing/contrib/sidekiq/server_tracer'
+            require_relative 'client_tracer'
+            require_relative 'server_tracer'
 
             ::Sidekiq.configure_client do |config|
               config.client_middleware do |chain|
@@ -45,24 +45,31 @@ module Datadog
             patch_server_heartbeat
             patch_server_job_fetch
             patch_server_scheduled_push
+            patch_redis_info
           end
 
           def patch_server_heartbeat
-            require 'datadog/tracing/contrib/sidekiq/server_internal_tracer/heartbeat'
+            require_relative 'server_internal_tracer/heartbeat'
 
             ::Sidekiq::Launcher.prepend(ServerInternalTracer::Heartbeat)
           end
 
           def patch_server_job_fetch
-            require 'datadog/tracing/contrib/sidekiq/server_internal_tracer/job_fetch'
+            require_relative 'server_internal_tracer/job_fetch'
 
             ::Sidekiq::Processor.prepend(ServerInternalTracer::JobFetch)
           end
 
           def patch_server_scheduled_push
-            require 'datadog/tracing/contrib/sidekiq/server_internal_tracer/scheduled_push'
+            require_relative 'server_internal_tracer/scheduled_poller'
 
-            ::Sidekiq::Scheduled::Poller.prepend(ServerInternalTracer::ScheduledPush)
+            ::Sidekiq::Scheduled::Poller.prepend(ServerInternalTracer::ScheduledPoller)
+          end
+
+          def patch_redis_info
+            require_relative 'server_internal_tracer/redis_info'
+
+            ::Sidekiq.singleton_class.prepend(ServerInternalTracer::RedisInfo)
           end
         end
       end

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

@@ -7,9 +7,27 @@ module Datadog
         module ServerInternalTracer
           # Trace when a Sidekiq process has a heartbeat
           module Heartbeat
+            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(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
+
             private
 
-            def ❤ # rubocop:disable Naming/AsciiIdentifiers, Naming/MethodName
+            def heartbeat
               configuration = Datadog.configuration.tracing[:sidekiq]
 
               Datadog::Tracing.trace(Ext::SPAN_HEARTBEAT, service: configuration[:service_name]) do |span|

data/lib/datadog/tracing/contrib/sidekiq/server_internal_tracer/{scheduled_push.rb → redis_info.rb}

@@ -5,17 +5,16 @@ module Datadog
     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 ScheduledPush
-            def enqueue
+          # Trace when Sidekiq gets Redis info on startup
+          module RedisInfo
+            def redis_info
               configuration = Datadog.configuration.tracing[:sidekiq]
 
-              Datadog::Tracing.trace(Ext::SPAN_SCHEDULED_PUSH, service: configuration[:service_name]) do |span|
+              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(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
-                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_SCHEDULED_PUSH)
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REDIS_INFO)
 
                 # Set analytics sample rate
                 if Contrib::Analytics.enabled?(configuration[:analytics_enabled])

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

@@ -0,0 +1,53 @@
+# typed: true
+
+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(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(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,10 @@
 # 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 +14,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 +25,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,
@@ -36,6 +40,11 @@ module Datadog
               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

@@ -2,8 +2,8 @@
 
 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,7 @@
 # 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

@@ -2,8 +2,8 @@
 
 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 +13,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 +38,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

@@ -10,9 +10,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 +23,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,5 @@
 # typed: false
 
-require 'datadog/tracing'
-
 module Datadog
   module Tracing
     module Contrib
@@ -39,6 +37,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,6 @@
 # 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,8 @@
 # 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,9 @@
-# typed: true
+# typed: false
 
-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
@@ -51,7 +50,7 @@ module Datadog
           end
 
           def patch
-            require 'datadog/tracing/contrib/sinatra/tracer'
+            require_relative 'tracer'
             register_tracer
 
             patch_default_middlewares
@@ -59,7 +58,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

@@ -2,14 +2,13 @@
 
 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 +17,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 +45,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 +69,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