ddtrace 0.39.0 → 0.40.0

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'ddtrace/contrib/analytics'
+
+module Datadog
+  module Contrib
+    module Que
+      # Tracer is a Que's server-side middleware which traces executed jobs
+      class Tracer
+        def call(job)
+          trace_options = {
+            service:   configuration[:service_name],
+            span_type: Datadog::Ext::AppTypes::WORKER
+          }
+
+          tracer.trace(Ext::SPAN_JOB, trace_options) do |request_span|
+            request_span.resource = job.class.name.to_s
+            request_span.set_tag(Ext::TAG_JOB_QUEUE, job.que_attrs[:queue])
+            request_span.set_tag(Ext::TAG_JOB_ID, job.que_attrs[:id])
+            request_span.set_tag(Ext::TAG_JOB_PRIORITY, job.que_attrs[:priority])
+            request_span.set_tag(Ext::TAG_JOB_ERROR_COUNT, job.que_attrs[:error_count])
+            request_span.set_tag(Ext::TAG_JOB_RUN_AT, job.que_attrs[:run_at])
+            request_span.set_tag(Ext::TAG_JOB_EXPIRED_AT, job.que_attrs[:expired_at])
+            request_span.set_tag(Ext::TAG_JOB_FINISHED_AT, job.que_attrs[:finished_at])
+            request_span.set_tag(Ext::TAG_JOB_ARGS, job.que_attrs[:args]) if configuration[:tag_args]
+            request_span.set_tag(Ext::TAG_JOB_DATA, job.que_attrs[:data]) if configuration[:tag_data]
+
+            set_sample_rate(request_span)
+            Contrib::Analytics.set_measured(request_span)
+
+            yield
+          end
+        end
+
+        private
+
+        def set_sample_rate(request_span)
+          if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+            Contrib::Analytics.set_sample_rate(
+              request_span,
+              configuration[:analytics_sample_rate]
+            )
+          end
+        end
+
+        def tracer
+          configuration[:tracer]
+        end
+
+        def configuration
+          Datadog.configuration[Datadog::Contrib::Que::Ext::APP.to_sym]
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/racecar/events.rb

@@ -1,5 +1,6 @@
 require 'ddtrace/contrib/racecar/events/batch'
 require 'ddtrace/contrib/racecar/events/message'
+require 'ddtrace/contrib/racecar/events/consume'
 
 module Datadog
   module Contrib
@@ -7,6 +8,7 @@ module Datadog
       # Defines collection of instrumented Racecar events
       module Events
         ALL = [
+          Events::Consume,
           Events::Batch,
           Events::Message
         ].freeze

data/lib/ddtrace/contrib/racecar/events/consume.rb

@@ -0,0 +1,27 @@
+require 'ddtrace/contrib/racecar/ext'
+require 'ddtrace/contrib/racecar/event'
+
+module Datadog
+  module Contrib
+    module Racecar
+      module Events
+        # Defines instrumentation for main_loop.racecar event
+        module Consume
+          include Racecar::Event
+
+          EVENT_NAME = 'main_loop.racecar'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            Ext::SPAN_CONSUME
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,6 +10,7 @@ module Datadog
         ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RACECAR_ANALYTICS_SAMPLE_RATE'.freeze
         ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_RACECAR_ANALYTICS_SAMPLE_RATE'.freeze
         SERVICE_NAME = 'racecar'.freeze
+        SPAN_CONSUME = 'racecar.consume'.freeze
         SPAN_BATCH = 'racecar.batch'.freeze
         SPAN_MESSAGE = 'racecar.message'.freeze
         TAG_CONSUMER = 'kafka.consumer'.freeze

data/lib/ddtrace/contrib/rack/middlewares.rb

@@ -4,6 +4,8 @@ require 'ddtrace/propagation/http_propagator'
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/rack/ext'
 require 'ddtrace/contrib/rack/request_queue'
+require 'ddtrace/environment'
+require 'date'
 
 module Datadog
   module Contrib

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

@@ -81,6 +81,11 @@ module Datadog
               Datadog.configuration[:action_view][:template_base_path] = value
             end
           end
+
+          option :log_injection do |o|
+            o.default { env_to_bool(Ext::ENV_LOGS_INJECTION_ENABLED, false) }
+            o.lazy
+          end
         end
       end
     end

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

@@ -10,6 +10,7 @@ module Datadog
         ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RAILS_ANALYTICS_SAMPLE_RATE'.freeze
         ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_RAILS_ANALYTICS_SAMPLE_RATE'.freeze
         ENV_DISABLE = 'DISABLE_DATADOG_RAILS'.freeze
+        ENV_LOGS_INJECTION_ENABLED = 'DD_LOGS_INJECTION'.freeze
       end
     end
   end

data/lib/ddtrace/contrib/rails/log_injection.rb

@@ -0,0 +1,81 @@
+module Datadog
+  module Contrib
+    # Instrument Rails.
+    module Rails
+      # Rails log injection helper methods
+      module LogInjection
+        module_function
+
+        def add_lograge_logger(app)
+          # custom_options defaults to nil and can be either a hash or a lambda which returns a hash
+          # https://github.com/roidrage/lograge/blob/1729eab7956bb95c5992e4adab251e4f93ff9280/lib/lograge.rb#L28
+          if (custom_options = app.config.lograge.custom_options).nil?
+            # if it's not set, we set to a lambda that returns DD tracing context
+            app.config.lograge.custom_options = lambda do |_event|
+              # Retrieves trace information for current thread
+              correlation = Datadog.tracer.active_correlation
+
+              datadog_trace_log_hash(correlation)
+            end
+          # check if lambda, if so then define a new lambda which invokes the original lambda and
+          # merges the returned hash with the the DD tracing context hash.
+          elsif custom_options.respond_to?(:call)
+            app.config.lograge.custom_options = lambda do |event|
+              # invoke original lambda
+              result = custom_options.call(event)
+              # Retrieves trace information for current thread
+              correlation = Datadog.tracer.active_correlation
+              # merge original lambda with datadog context
+              result.merge(datadog_trace_log_hash(correlation))
+            end
+          # otherwise if it's just a static hash, we have to wrap that hash in a lambda to retrieve
+          # the DD tracing context, then merge the tracing context with the original static hash.
+          # don't modify if custom_options is not an accepted format.
+          elsif custom_options.is_a?(Hash)
+            app.config.lograge.custom_options = lambda do |_event|
+              # Retrieves trace information for current thread
+              correlation = Datadog.tracer.active_correlation
+
+              # merge original lambda with datadog context
+              custom_options.merge(datadog_trace_log_hash(correlation))
+            end
+          end
+        rescue StandardError => e
+          # TODO: can we use Datadog.logger at this point?
+          Datadog.logger.warn("Unable to add Datadog Trace context to Lograge: #{e.message}")
+          false
+        end
+
+        def add_as_tagged_logging_logger(app)
+          # we want to check if the current logger is a tagger logger instance
+          # log_tags defaults to nil so we have to set as an array if nothing exists yet
+          if (log_tags = app.config.log_tags).nil?
+            app.config.log_tags = [proc { Datadog.tracer.active_correlation.to_s }]
+          # if existing log_tags configuration exists, append to the end of the array
+          elsif log_tags.is_a?(Array)
+            app.config.log_tags << proc { Datadog.tracer.active_correlation.to_s }
+          end
+        rescue StandardError => e
+          # TODO: can we use Datadog.logger at this point?
+          Datadog.logger.warn("Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.message}")
+          false
+        end
+
+        def datadog_trace_log_hash(correlation)
+          {
+            # Adds IDs as tags to log output
+            dd: {
+              # To preserve precision during JSON serialization, use strings for large numbers
+              trace_id: correlation.trace_id.to_s,
+              span_id: correlation.span_id.to_s,
+              env: correlation.env.to_s,
+              service: correlation.service.to_s,
+              version: correlation.version.to_s
+            },
+            ddsource: ['ruby']
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/rails/middlewares.rb

@@ -24,11 +24,16 @@ module Datadog
         rescue Exception => e
           tracer = Datadog.configuration[:rails][:tracer]
           span = tracer.active_span
-          unless span.nil?
+          if !span.nil? && ActionPack::Utils.exception_is_error?(e)
             # Only set error if it's supposed to be flagged as such
             # e.g. we don't want to flag 404s.
             # You can add custom errors via `config.action_dispatch.rescue_responses`
-            span.set_error(e) if ActionPack::Utils.exception_is_error?(e)
+            span.set_error(e)
+
+            # Some exception gets handled by Rails middleware before it can be set on Rack middleware
+            # The rack span is the root span of the request and should make sure it has the full exception
+            # set on it.
+            env[:datadog_rack_request_span].set_error(e) if env[:datadog_rack_request_span]
           end
           raise e
         end

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

@@ -1,6 +1,7 @@
 require 'ddtrace/contrib/rails/utils'
 require 'ddtrace/contrib/rails/framework'
 require 'ddtrace/contrib/rails/middlewares'
+require 'ddtrace/contrib/rails/log_injection'
 require 'ddtrace/contrib/rack/middlewares'
 
 module Datadog
@@ -33,6 +34,7 @@ module Datadog
             # Otherwise the middleware stack will be frozen.
             # Sometimes we don't want to activate middleware e.g. OpenTracing, etc.
             add_middleware(app) if Datadog.configuration[:rails][:middleware]
+            add_logger(app) if Datadog.configuration[:rails][:log_injection]
           end
         end
 
@@ -50,6 +52,19 @@ module Datadog
           )
         end
 
+        def add_logger(app)
+          # check if lograge key exists
+          if app.config.respond_to?(:lograge) && app.config.lograge.enabled
+            Datadog::Contrib::Rails::LogInjection.add_lograge_logger(app)
+          # if lograge isn't set, check if tagged logged is enabed.
+          # if so, add proc that injects trace identifiers for tagged logging.
+          elsif (logger = app.config.logger) && logger.is_a?(::ActiveSupport::TaggedLogging)
+            Datadog::Contrib::Rails::LogInjection.add_as_tagged_logging_logger(app)
+          else
+            Datadog.logger.warn("Unabe to enable Datadog Trace context, Logger #{logger} is not supported")
+          end
+        end
+
         def patch_after_intialize
           ::ActiveSupport.on_load(:after_initialize) do
             Datadog::Contrib::Rails::Patcher.after_intialize(self)

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/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