ddtrace 0.13.0 → 0.47.0

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

@@ -1,32 +1,40 @@
+require 'ddtrace/contrib/patcher'
+
 module Datadog
   module Contrib
     module Sidekiq
-      # Provides instrumentation support for Sidekiq
+      # Patcher enables patching of 'sidekiq' module.
       module Patcher
-        include Base
-        VERSION_REQUIRED = Gem::Version.new('4.0.0')
-        register_as :sidekiq
-        option :service_name, default: 'sidekiq'
-        option :tracer, default: Datadog.tracer
+        include Contrib::Patcher
 
         module_function
 
+        def target_version
+          Integration.version
+        end
+
         def patch
-          return unless compatible?
+          require 'ddtrace/contrib/sidekiq/client_tracer'
+          require 'ddtrace/contrib/sidekiq/server_tracer'
 
-          require_relative 'tracer'
+          ::Sidekiq.configure_client do |config|
+            config.client_middleware do |chain|
+              chain.add(Sidekiq::ClientTracer)
+            end
+          end
 
           ::Sidekiq.configure_server do |config|
+            # If a job enqueues another job, make sure it has the same client
+            # middleware.
+            config.client_middleware do |chain|
+              chain.add(Sidekiq::ClientTracer)
+            end
+
             config.server_middleware do |chain|
-              chain.add(Sidekiq::Tracer)
+              chain.add(Sidekiq::ServerTracer)
             end
           end
         end
-
-        def compatible?
-          defined?(::Sidekiq) &&
-            Gem::Version.new(::Sidekiq::VERSION) >= VERSION_REQUIRED
-        end
       end
     end
   end

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

@@ -0,0 +1,65 @@
+require 'ddtrace/contrib/sidekiq/tracing'
+require 'ddtrace/contrib/analytics'
+
+module Datadog
+  module Contrib
+    module Sidekiq
+      # Tracer is a Sidekiq server-side middleware which traces executed jobs
+      class ServerTracer
+        include Tracing
+
+        def initialize(options = {})
+          super
+          @sidekiq_service = options[:service_name] || configuration[:service_name]
+          @error_handler = options[:error_handler] || configuration[:error_handler]
+        end
+
+        def call(worker, job, queue)
+          resource = job_resource(job)
+
+          service = worker_config(resource, :service_name) || @sidekiq_service
+          tag_args = worker_config(resource, :tag_args) || configuration[:tag_args]
+
+          @tracer.trace(Ext::SPAN_JOB, service: service, span_type: Datadog::Ext::AppTypes::WORKER,
+                                       on_error: @error_handler) do |span|
+            span.resource = resource
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
+            span.set_tag(Ext::TAG_JOB_ID, job['jid'])
+            span.set_tag(Ext::TAG_JOB_RETRY, job['retry'])
+            span.set_tag(Ext::TAG_JOB_RETRY_COUNT, job['retry_count'])
+            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?
+
+            yield
+          end
+        end
+
+        private
+
+        def configuration
+          Datadog.configuration[:sidekiq]
+        end
+
+        def worker_config(resource, key)
+          # Try to get the Ruby class from the resource name.
+          worker_klass = begin
+            Object.const_get(resource)
+          rescue NameError
+            nil
+          end
+
+          worker_klass.datadog_tracer_config[key] if worker_klass.respond_to?(:datadog_tracer_config)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/sidekiq/ext'
+
+require 'yaml'
+
+module Datadog
+  module Contrib
+    module Sidekiq
+      # Common functionality used by both client-side and server-side tracers.
+      module Tracing
+        def initialize(options = {})
+          @tracer = options[:tracer] || Datadog.configuration[:sidekiq][:tracer]
+        end
+
+        protected
+
+        # If class is wrapping something else, the interesting resource info
+        # is the underlying, wrapped class, and not the wrapper. This is
+        # primarily to support `ActiveJob`.
+        def job_resource(job)
+          if job['wrapped']
+            job['wrapped'].to_s
+          elsif job['class'] == 'Sidekiq::Extensions::DelayedClass'
+            delay_extension_class(job).to_s
+          else
+            job['class'].to_s
+          end
+        rescue => e
+          Datadog.logger.debug { "Error retrieving Sidekiq job class name (jid:#{job['jid']}): #{e}" }
+
+          job['class'].to_s
+        end
+
+        def delay_extension_class(job)
+          clazz, method = YAML.parse(job['args'].first).children.first.children
+
+          method = method.value[1..-1] # Remove leading `:` from method symbol
+
+          "#{clazz.value}.#{method}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/sinatra/ext'
+
+module Datadog
+  module Contrib
+    module Sinatra
+      module Configuration
+        # Custom settings for the Sinatra integration
+        class Settings < Contrib::Configuration::Settings
+          DEFAULT_HEADERS = {
+            response: %w[Content-Type X-Request-ID]
+          }.freeze
+
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
+          option :analytics_enabled do |o|
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], nil) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
+            o.lazy
+          end
+
+          option :distributed_tracing, default: true
+          option :headers, default: DEFAULT_HEADERS
+          option :resource_script_names, default: false
+
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -1,20 +1,20 @@
 require 'ddtrace/ext/http'
+require 'ddtrace/contrib/sinatra/ext'
 
 module Datadog
   module Contrib
     module Sinatra
       # Gets and sets trace information from a Rack Env
       module Env
-        ENV_SPAN = 'datadog.sinatra_request_span'.freeze
-
         module_function
 
-        def datadog_span(env)
-          env[ENV_SPAN]
+        def datadog_span(env, app)
+          env[Ext::RACK_ENV_REQUEST_SPAN][app]
         end
 
-        def set_datadog_span(env, span)
-          env[ENV_SPAN] = span
+        def set_datadog_span(env, app, span)
+          hash = (env[Ext::RACK_ENV_REQUEST_SPAN] ||= {})
+          hash[app] = span
         end
 
         def request_header_tags(env, headers)
@@ -23,9 +23,7 @@ module Datadog
           {}.tap do |result|
             headers.each do |header|
               rack_header = header_to_rack_header(header)
-              if env.key?(rack_header)
-                result[Datadog::Ext::HTTP::RequestHeaders.to_tag(header)] = env[rack_header]
-              end
+              result[Datadog::Ext::HTTP::RequestHeaders.to_tag(header)] = env[rack_header] if env.key?(rack_header)
             end
           end
         end
@@ -33,6 +31,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

@@ -0,0 +1,27 @@
+module Datadog
+  module Contrib
+    module Sinatra
+      # Sinatra integration constants
+      module Ext
+        APP = 'sinatra'.freeze
+        ENV_ENABLED = 'DD_TRACE_SINATRA_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_SINATRA_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_SINATRA_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SINATRA_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = '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
+  end
+end

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

@@ -18,9 +18,7 @@ module Datadog
                 # Try a case-insensitive lookup
                 uppercased_header = header.to_s.upcase
                 matching_header = headers.keys.find { |h| h.upcase == uppercased_header }
-                if matching_header
-                  result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[matching_header]
-                end
+                result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[matching_header] if matching_header
               end
             end
           end

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

@@ -0,0 +1,38 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/sinatra/configuration/settings'
+require 'ddtrace/contrib/sinatra/patcher'
+
+module Datadog
+  module Contrib
+    module Sinatra
+      # Description of Sinatra integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('1.4')
+
+        register_as :sinatra
+
+        def self.version
+          Gem.loaded_specs['sinatra'] && Gem.loaded_specs['sinatra'].version
+        end
+
+        def self.loaded?
+          !defined?(::Sinatra).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'ddtrace/contrib/patcher'
+
+module Datadog
+  module Contrib
+    module Sinatra
+      # Patcher enables patching of 'sinatra' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          require 'ddtrace/contrib/sinatra/tracer'
+          register_tracer
+        end
+
+        def register_tracer
+          ::Sinatra.send(:register, Datadog::Contrib::Sinatra::Tracer)
+          ::Sinatra::Base.send(:prepend, Sinatra::Tracer::Base)
+        end
+      end
+    end
+  end
+end

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

@@ -5,47 +5,26 @@ require 'ddtrace/ext/errors'
 require 'ddtrace/ext/http'
 require 'ddtrace/propagation/http_propagator'
 
+require 'ddtrace/contrib/sinatra/ext'
 require 'ddtrace/contrib/sinatra/tracer_middleware'
 require 'ddtrace/contrib/sinatra/env'
 
-sinatra_vs = Gem::Version.new(Sinatra::VERSION)
-sinatra_min_vs = Gem::Version.new('1.4.0')
-if sinatra_vs < sinatra_min_vs
-  raise "sinatra version #{sinatra_vs} is not supported yet " \
-          + "(supporting versions >=#{sinatra_min_vs})"
-end
-
-Datadog::Tracer.log.info("activating instrumentation for sinatra #{sinatra_vs}")
-
 module Datadog
   module Contrib
     module Sinatra
       # Datadog::Contrib::Sinatra::Tracer is a Sinatra extension which traces
       # requests.
       module Tracer
-        DEFAULT_HEADERS = {
-          response: %w[Content-Type X-Request-ID]
-        }.freeze
-
-        include Base
-        register_as :sinatra
-
-        option :service_name, default: 'sinatra', depends_on: [:tracer] do |value|
-          get_option(:tracer).set_service_info(value, 'sinatra', Ext::AppTypes::WEB)
-          value
-        end
-
-        option :tracer, default: Datadog.tracer
-        option :resource_script_names, default: false
-        option :distributed_tracing, default: false
-        option :headers, default: DEFAULT_HEADERS
-
         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[:sinatra][:resource_script_names]
                                "#{request.script_name}#{action}"
                              else
@@ -57,57 +36,92 @@ 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('sinatra.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('sinatra.template_name', data) if data.is_a? Symbol
-                  output = super
-                end
-              else
-                output = super
-              end
-
-              output
-            end
+          app.use TracerMiddleware, app_instance: app
+
+          app.after do
+            configuration = Datadog.configuration[:sinatra]
+            next unless configuration[:tracer].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
+          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)
 
-          app.use TracerMiddleware
+              # 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
 
-          app.before do
-            return unless Datadog.configuration[:sinatra][:tracer].enabled
+              # Measure service stats
+              Contrib::Analytics.set_measured(span)
 
-            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)
+              super
+            end
           end
 
-          app.after do
-            return unless Datadog.configuration[:sinatra][:tracer].enabled
+          # 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
 
-            span = 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}"
 
-            unless span
-              Datadog::Tracer.log.error('missing request span in :after hook')
-              return
-            end
+              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_SCRIPT_NAME, request.script_name) if request.script_name && !request.script_name.empty?
 
-            span.resource = "#{request.request_method} #{@datadog_route}"
-            span.set_tag('sinatra.route.path', @datadog_route)
-            span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
-            span.set_error(env['sinatra.error']) if response.server_error?
+              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
     end
   end
 end
-
-# rubocop:disable Style/Documentation
-module Sinatra
-  register Datadog::Contrib::Sinatra::Tracer
-end