ls-trace 0.1.2 → 0.2.0

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

@@ -9,18 +9,20 @@ module Datadog
       class Integration
         include Contrib::Integration
 
+        MINIMUM_VERSION = Gem::Version.new('3.5.4')
+
         register_as :sidekiq
 
         def self.version
           Gem.loaded_specs['sidekiq'] && Gem.loaded_specs['sidekiq'].version
         end
 
-        def self.present?
-          super && defined?(::Sidekiq)
+        def self.loaded?
+          !defined?(::Sidekiq).nil?
         end
 
         def self.compatible?
-          super && version >= Gem::Version.new('3.5.4')
+          super && version >= MINIMUM_VERSION
         end
 
         def default_configuration

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

@@ -9,28 +9,29 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:sidekiq)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:sidekiq) do
-            begin
-              require 'ddtrace/contrib/sidekiq/client_tracer'
-              ::Sidekiq.configure_client do |config|
-                config.client_middleware do |chain|
-                  chain.add(Sidekiq::ClientTracer)
-                end
-              end
+          require 'ddtrace/contrib/sidekiq/client_tracer'
+          require 'ddtrace/contrib/sidekiq/server_tracer'
 
-              require 'ddtrace/contrib/sidekiq/server_tracer'
-              ::Sidekiq.configure_server do |config|
-                config.server_middleware do |chain|
-                  chain.add(Sidekiq::ServerTracer)
-                end
-              end
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Sidekiq integration: #{e}")
+          ::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::ServerTracer)
             end
           end
         end

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

@@ -16,7 +16,8 @@ module Datadog
         def call(worker, job, queue)
           resource = job_resource(job)
 
-          service = service_from_worker_config(resource) || @sidekiq_service
+          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) do |span|
             span.resource = resource
@@ -24,11 +25,19 @@ module Datadog
             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))
+            if tag_args && !job['args'].nil? && !job['args'].empty?
+              span.set_tag(Ext::TAG_JOB_ARGS, job['args'])
+            end
 
             yield
           end
@@ -40,7 +49,7 @@ module Datadog
           Datadog.configuration[:sidekiq]
         end
 
-        def service_from_worker_config(resource)
+        def worker_config(resource, key)
           # Try to get the Ruby class from the resource name.
           worker_klass = begin
             Object.const_get(resource)
@@ -49,7 +58,7 @@ module Datadog
           end
 
           if worker_klass.respond_to?(:datadog_tracer_config)
-            worker_klass.datadog_tracer_config[:service_name]
+            worker_klass.datadog_tracer_config[key]
           end
         end
       end

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

@@ -1,6 +1,8 @@
 require 'ddtrace/ext/app_types'
 require 'ddtrace/contrib/sidekiq/ext'
 
+require 'yaml'
+
 module Datadog
   module Contrib
     module Sidekiq
@@ -17,10 +19,25 @@ module Datadog
         # primarily to support `ActiveJob`.
         def job_resource(job)
           if job['wrapped']
-            job['wrapped']
+            job['wrapped'].to_s
+          elsif job['class'] == 'Sidekiq::Extensions::DelayedClass'
+            delay_extension_class(job).to_s
           else
-            job['class']
+            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

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)
@@ -32,6 +33,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

@@ -4,13 +4,22 @@ 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
         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

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

@@ -9,18 +9,20 @@ module Datadog
       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.present?
-          super && defined?(::Sinatra)
+        def self.loaded?
+          !defined?(::Sinatra).nil?
         end
 
         def self.compatible?
-          super && version >= Gem::Version.new('1.4.0')
+          super && version >= MINIMUM_VERSION
         end
 
         def default_configuration

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

@@ -9,23 +9,18 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:sinatra)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:sinatra) do
-            begin
-              require 'ddtrace/contrib/sinatra/tracer'
-              register_tracer
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Sinatra integration: #{e}")
-            end
-          end
+          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

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

@@ -21,6 +21,10 @@ module Datadog
           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
@@ -32,50 +36,91 @@ 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(Ext::SPAN_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(Ext::TAG_TEMPLATE_NAME, data) if data.is_a? Symbol
-
-                  output = super
-                end
-              else
-                output = super
-              end
+          app.use TracerMiddleware, app_instance: app
 
-              output
-            end
-          end
+          app.after do
+            configuration = Datadog.configuration[:sinatra]
+            next unless configuration[:tracer].enabled
 
-          app.use TracerMiddleware
+            span = Sinatra::Env.datadog_span(env, app)
 
-          app.before do
-            return unless Datadog.configuration[:sinatra][:tracer].enabled
+            # 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 = Sinatra::Env.datadog_span(env)
-            span.set_tag(Datadog::Ext::HTTP::URL, request.path)
-            span.set_tag(Datadog::Ext::HTTP::METHOD, request.request_method)
+            span.resource = "#{request.request_method} #{route}"
+            span.set_tag(Ext::TAG_ROUTE_PATH, route)
           end
+        end
 
-          app.after do
-            return unless Datadog.configuration[:sinatra][:tracer].enabled
+        # 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)
+
+              # 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
 
-            span = Sinatra::Env.datadog_span(env)
+              # Measure service stats
+              Contrib::Analytics.set_measured(span)
 
-            unless span
-              Datadog::Tracer.log.error('missing request span in :after hook')
-              return
+              super
             end
+          end
+
+          # 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
+
+            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}"
+
+              span.set_tag(Ext::TAG_APP_NAME, settings.name || settings.superclass.name)
+              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
+
+              rack_request_span = env[Datadog::Contrib::Rack::TraceMiddleware::RACK_REQUEST_SPAN]
+              rack_request_span.resource = span.resource if rack_request_span
 
-            span.resource = "#{request.request_method} #{@datadog_route}"
-            span.set_tag(Ext::TAG_ROUTE_PATH, @datadog_route)
-            span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
-            span.set_error(env['sinatra.error']) if response.server_error?
+              Contrib::Analytics.set_measured(span)
+
+              super
+            end
           end
         end
       end

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,29 +22,59 @@ module Datadog
             tracer.provider.context = context if context.trace_id
           end
 
-          # Begin the trace
           tracer.trace(
             Ext::SPAN_REQUEST,
             service: configuration[:service_name],
-            span_type: Datadog::Ext::HTTP::TYPE_INBOUND
+            span_type: Datadog::Ext::HTTP::TYPE_INBOUND,
+            resource: env['REQUEST_METHOD']
           ) do |span|
-            Sinatra::Env.set_datadog_span(env, span)
+            begin
+              Sinatra::Env.set_datadog_span(env, @app_instance, 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
+              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
 
-            # Run application stack
-            status, headers, response_body = @app.call(env)
+              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
 
-            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
+              span.set_tag(Ext::TAG_APP_NAME, @app_instance.settings.name)
+
+              # 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
+
+              if response
+                if (status = response[0])
+                  sinatra_response = ::Sinatra::Response.new([], status) # Build object to use status code helpers
 
-            # Set analytics sample rate
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+                  span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, sinatra_response.status)
+                  span.set_error(env['sinatra.error']) if sinatra_response.server_error?
+                end
 
-            [status, headers, response_body]
+                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