ddtrace 0.37.0 → 0.42.0

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

@@ -31,6 +31,7 @@ module Datadog
 
             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))

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

@@ -12,13 +12,18 @@ module Datadog
             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, nil) }
+            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, 1.0) }
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
             o.lazy
           end
 

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

@@ -8,12 +8,13 @@ module Datadog
       module Env
         module_function
 
-        def datadog_span(env)
-          env[Ext::RACK_ENV_REQUEST_SPAN]
+        def datadog_span(env, app)
+          env[Ext::RACK_ENV_REQUEST_SPAN][app]
         end
 
-        def set_datadog_span(env, span)
-          env[Ext::RACK_ENV_REQUEST_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)

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

@@ -4,8 +4,11 @@ module Datadog
       # Sinatra integration constants
       module Ext
         APP = 'sinatra'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_SINATRA_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_SINATRA_ANALYTICS_SAMPLE_RATE'.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

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

@@ -36,21 +36,32 @@ module Datadog
         end
 
         def self.registered(app)
-          app.use TracerMiddleware
+          app.use TracerMiddleware, app_instance: app
 
           app.after do
             configuration = Datadog.configuration[:sinatra]
             next unless configuration[:tracer].enabled
 
-            # Ensures we only create a span for the top-most Sinatra middleware.
-            #
-            # If we traced all Sinatra middleware apps, we would have a chain
-            # of nested spans that were not responsible for handling this request,
-            # adding little value to users.
-            next if Sinatra::Env.middleware_traced?(env)
-
-            span = Sinatra::Env.datadog_span(env) || Sinatra::Tracer.create_middleware_span(env, configuration)
-
+            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
@@ -59,36 +70,10 @@ module Datadog
                     end
 
             span.resource = "#{request.request_method} #{route}"
-
-            span.set_tag(Datadog::Ext::HTTP::URL, request.path)
-            span.set_tag(Datadog::Ext::HTTP::METHOD, request.request_method)
-            span.set_tag(Ext::TAG_APP_NAME, app.settings.name)
             span.set_tag(Ext::TAG_ROUTE_PATH, route)
-            if request.script_name && !request.script_name.empty?
-              span.set_tag(Ext::TAG_SCRIPT_NAME, request.script_name)
-            end
-
-            span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
-            span.set_error(env['sinatra.error']) if response.server_error?
-
-            Sinatra::Env.set_middleware_traced(env, true)
           end
         end
 
-        # Initializes a span for the top-most Sinatra middleware.
-        def self.create_middleware_span(env, configuration)
-          tracer = configuration[:tracer]
-          span = tracer.trace(
-            Ext::SPAN_REQUEST,
-            service: configuration[:service_name],
-            span_type: Datadog::Ext::HTTP::TYPE_INBOUND,
-            start_time: Sinatra::Env.middleware_start_time(env)
-          )
-
-          Sinatra::Env.set_datadog_span(env, span)
-          span
-        end
-
         # Method overrides for Sinatra::Base
         module Base
           def render(engine, data, *)
@@ -114,14 +99,8 @@ module Datadog
           def route_eval
             configuration = Datadog.configuration[:sinatra]
             tracer = configuration[:tracer]
-
             return super unless tracer.enabled
 
-            # For initialization of Sinatra middleware span in order
-            # guarantee that the Ext::SPAN_ROUTE span being created below
-            # has the middleware span as its parent.
-            Sinatra::Tracer.create_middleware_span(env, configuration) unless Sinatra::Env.datadog_span(env)
-
             tracer.trace(
               Ext::SPAN_ROUTE,
               service: configuration[:service_name],

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

@@ -8,10 +8,13 @@ module Datadog
     module Sinatra
       # Middleware used for automatically tagging configured headers and handle request span
       class TracerMiddleware
-        def initialize(app)
+        def initialize(app, app_instance: nil)
           @app = app
+          @app_instance = app_instance
         end
 
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
         def call(env)
           # Set the trace context (e.g. distributed tracing)
           if configuration[:distributed_tracing] && tracer.provider.context.trace_id.nil?
@@ -19,35 +22,59 @@ module Datadog
             tracer.provider.context = context if context.trace_id
           end
 
-          Sinatra::Env.set_middleware_start_time(env)
+          tracer.trace(
+            Ext::SPAN_REQUEST,
+            service: configuration[:service_name],
+            span_type: Datadog::Ext::HTTP::TYPE_INBOUND,
+            resource: env['REQUEST_METHOD']
+          ) do |span|
+            begin
+              Sinatra::Env.set_datadog_span(env, @app_instance, span)
 
-          # Run application stack
-          response = @app.call(env)
-        ensure
-          # Augment current Sinatra middleware span if we are the top-most Sinatra app on the Rack stack.
-          span = Sinatra::Env.datadog_span(env)
-          if span
-            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
-
-            if response && (headers = response[1])
-              Sinatra::Headers.response_header_tags(headers, configuration[:headers][:response]).each do |name, value|
+              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
-            end
 
-            # Set analytics sample rate
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+              request = ::Sinatra::Request.new(env)
+              span.set_tag(Datadog::Ext::HTTP::URL, request.path)
+              span.set_tag(Datadog::Ext::HTTP::METHOD, request.request_method)
+              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)
 
-            # Measure service stats
-            Contrib::Analytics.set_measured(span)
+              # TODO: This backfills the non-matching Sinatra app with a "#{method} #{path}"
+              # TODO: resource name. This shouldn't be the case, as that app has never handled
+              # TODO: the response with that resource.
+              # TODO: We should replace this backfill code with a clear `resource` that signals
+              # TODO: that this Sinatra span was *not* responsible for processing the current request.
+              rack_request_span = env[Datadog::Contrib::Rack::TraceMiddleware::RACK_REQUEST_SPAN]
+              span.resource = rack_request_span.resource if rack_request_span && rack_request_span.resource
 
-            span.finish
+              if response
+                if (status = response[0])
+                  sinatra_response = ::Sinatra::Response.new([], status) # Build object to use status code helpers
 
-            # Remove span from env, so other Sinatra apps mounted on this same
-            # Rack stack do not modify it with their own information.
-            Sinatra::Env.set_datadog_span(env, nil)
+                  span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, sinatra_response.status)
+                  span.set_error(env['sinatra.error']) if sinatra_response.server_error?
+                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
+                end
+              end
+
+              # Set analytics sample rate
+              Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+              # Measure service stats
+              Contrib::Analytics.set_measured(span)
+            end
           end
         end
 

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'ddtrace/contrib/configuration/settings'
+
+module Datadog
+  module Contrib
+    module Sneakers
+      module Configuration
+        # Default settings for the Shoryuken integration
+        class Settings < Datadog::Contrib::Configuration::Settings
+          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], false) }
+            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 :service_name, default: Ext::SERVICE_NAME
+          option :tag_body, default: false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Contrib
+    module Sneakers
+      # Sneakers integration constants
+      module Ext
+        APP = 'sneakers'.freeze
+        ENV_ENABLED = 'DD_TRACE_SNEAKERS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_SNEAKERS_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_SNEAKERS_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SNEAKERS_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_SNEAKERS_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'sneakers'.freeze
+        SPAN_JOB = 'sneakers.job'.freeze
+        TAG_JOB_ROUTING_KEY = 'sneakers.routing_key'.freeze
+        TAG_JOB_QUEUE = 'sneakers.queue'.freeze
+        TAG_JOB_BODY = 'sneakers.body'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/sneakers/ext'
+require 'ddtrace/contrib/sneakers/configuration/settings'
+require 'ddtrace/contrib/sneakers/patcher'
+
+module Datadog
+  module Contrib
+    module Sneakers
+      # Description of Sneakers integration
+      class Integration
+        include Datadog::Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('2.12.0')
+
+        register_as :sneakers, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['sneakers'] && Gem.loaded_specs['sneakers'].version
+        end
+
+        def self.loaded?
+          !defined?(::Sneakers).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/sneakers/patcher.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'ddtrace/contrib/sneakers/tracer'
+
+module Datadog
+  module Contrib
+    module Sneakers
+      # Patcher enables patching of 'sneakers' module.
+      module Patcher
+        include Datadog::Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          ::Sneakers.middleware.use(Sneakers::Tracer, nil)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'ddtrace/contrib/analytics'
+
+module Datadog
+  module Contrib
+    module Sneakers
+      # Tracer is a Sneakers server-side middleware which traces executed jobs
+      class Tracer
+        def initialize(app, *args)
+          @app = app
+          @args = args
+        end
+
+        def call(deserialized_msg, delivery_info, metadata, handler)
+          trace_options = {
+            service:   configuration[:service_name],
+            span_type: Datadog::Ext::AppTypes::WORKER
+          }
+          request_span = tracer.trace(Ext::SPAN_JOB, trace_options)
+
+          # Set analytics sample rate
+          if Datadog::Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+            Datadog::Contrib::Analytics.set_sample_rate(request_span, configuration[:analytics_sample_rate])
+          end
+
+          # Measure service stats
+          Contrib::Analytics.set_measured(request_span)
+
+          request_span.resource = @app.to_proc.binding.eval('self.class').to_s
+          request_span.set_tag(Ext::TAG_JOB_ROUTING_KEY, delivery_info.routing_key)
+          request_span.set_tag(Ext::TAG_JOB_QUEUE, delivery_info.consumer.queue.name)
+
+          if configuration[:tag_body]
+            request_span.set_tag(Ext::TAG_JOB_BODY, deserialized_msg)
+          end
+
+          @app.call(deserialized_msg, delivery_info, metadata, handler)
+        rescue StandardError => e
+          request_span.set_error(e) unless request_span.nil?
+          raise e
+        ensure
+          request_span.finish if request_span
+        end
+
+        private
+
+        def tracer
+          configuration[:tracer]
+        end
+
+        def configuration
+          Datadog.configuration[:sneakers]
+        end
+      end
+    end
+  end
+end

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

@@ -7,13 +7,18 @@ module Datadog
       module Configuration
         # Custom settings for the SuckerPunch integration
         class Settings < Contrib::Configuration::Settings
+          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, false) }
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
             o.lazy
           end
 
           option :analytics_sample_rate do |o|
-            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
             o.lazy
           end