ddtrace 0.37.0 → 0.42.0

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'ddtrace/contrib/que/tracer'
+
+module Datadog
+  module Contrib
+    module Que
+      # Patcher enables patching of 'que' module.
+      module Patcher
+        include Datadog::Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          ::Que.job_middleware.push(Que::Tracer.new)
+        end
+      end
+    end
+  end
+end

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/configuration/settings.rb

@@ -7,13 +7,18 @@ module Datadog
       module Configuration
         # Custom settings for the Racecar 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
 

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

@@ -1,6 +1,7 @@
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/active_support/notifications/event'
 require 'ddtrace/contrib/racecar/ext'
+require 'ddtrace/ext/integration'
 
 module Datadog
   module Contrib
@@ -37,6 +38,9 @@ module Datadog
             span.service = configuration[:service_name]
             span.resource = payload[:consumer_class]
 
+            # Tag as an external peer service
+            span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
+
             # Set analytics sample rate
             if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
               Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])

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

@@ -4,9 +4,13 @@ module Datadog
       # Racecar integration constants
       module Ext
         APP = 'racecar'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_RACECAR_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_RACECAR_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ENABLED = 'DD_TRACE_RACECAR_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_RACECAR_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_RACECAR_ANALYTICS_ENABLED'.freeze
+        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/configuration/settings.rb

@@ -14,13 +14,18 @@ module Datadog
             ]
           }.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/rack/ext.rb

@@ -4,8 +4,11 @@ module Datadog
       # Rack integration constants
       module Ext
         APP = 'rack'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_RACK_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_RACK_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ENABLED = 'DD_TRACE_RACK_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_RACK_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_RACK_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RACK_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_RACK_ANALYTICS_SAMPLE_RATE'.freeze
         RACK_ENV_REQUEST_SPAN = 'datadog.rack_request_span'.freeze
         SERVICE_NAME = 'rack'.freeze
         SPAN_HTTP_SERVER_QUEUE = 'http_server.queue'.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
@@ -98,23 +100,26 @@ module Datadog
           request_span.set_error(e) unless request_span.nil?
           raise e
         ensure
-          # Rack is a really low level interface and it doesn't provide any
-          # advanced functionality like routers. Because of that, we assume that
-          # the underlying framework or application has more knowledge about
-          # the result for this request; `resource` and `tags` are expected to
-          # be set in another level but if they're missing, reasonable defaults
-          # are used.
-          set_request_tags!(request_span, env, status, headers, response, original_env)
-
-          # ensure the request_span is finished and the context reset;
-          # this assumes that the Rack middleware creates a root span
-          request_span.finish
+          if request_span
+            # Rack is a really low level interface and it doesn't provide any
+            # advanced functionality like routers. Because of that, we assume that
+            # the underlying framework or application has more knowledge about
+            # the result for this request; `resource` and `tags` are expected to
+            # be set in another level but if they're missing, reasonable defaults
+            # are used.
+            set_request_tags!(request_span, env, status, headers, response, original_env || env)
+
+            # ensure the request_span is finished and the context reset;
+            # this assumes that the Rack middleware creates a root span
+            request_span.finish
+          end
+
           frontend_span.finish unless frontend_span.nil?
 
           # TODO: Remove this once we change how context propagation works. This
           # ensures we clean thread-local variables on each HTTP request avoiding
           # memory leaks.
-          tracer.provider.context = Datadog::Context.new
+          tracer.provider.context = Datadog::Context.new if tracer
         end
 
         def resource_name_for(env, status)

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

@@ -19,8 +19,13 @@ module Datadog
             analytics_sample_rate
           end
 
+          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
             o.on_set do |value|
               # Update ActionPack analytics too
@@ -29,7 +34,7 @@ module Datadog
           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
             o.on_set do |value|
               # Update ActionPack analytics too
@@ -76,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

@@ -4,9 +4,13 @@ module Datadog
       # Rails integration constants
       module Ext
         APP = 'rails'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_RAILS_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_RAILS_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ENABLED = 'DD_TRACE_RAILS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAILS_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_RAILS_ANALYTICS_ENABLED'.freeze
+        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,30 @@ module Datadog
           )
         end
 
+        def add_logger(app)
+          # check if lograge key exists
+          # Note: Rails executes initializers sequentially based on alphabetical order,
+          # and lograge config could occur after dd config.
+          # Checking for `app.config.lograge.enabled` may yield a false negative.
+          # Instead we should naively add custom options if `config.lograge` exists from the lograge Railtie,
+          # since the custom options get ignored without lograge explicitly being enabled.
+          # See: https://github.com/roidrage/lograge/blob/1729eab7956bb95c5992e4adab251e4f93ff9280/lib/lograge/railtie.rb#L7-L12
+          if app.config.respond_to?(:lograge)
+            Datadog::Contrib::Rails::LogInjection.add_lograge_logger(app)
+          end
+
+          # if lograge isn't set, check if tagged logged is enabled.
+          # if so, add proc that injects trace identifiers for tagged logging.
+          if (logger = app.config.logger) &&
+             defined?(::ActiveSupport::TaggedLogging) &&
+             logger.is_a?(::ActiveSupport::TaggedLogging)
+
+            Datadog::Contrib::Rails::LogInjection.add_as_tagged_logging_logger(app)
+          else
+            Datadog.logger.warn("Unable 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)