ddtrace 0.39.0 → 0.44.0

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

@@ -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,33 @@ module Datadog
           )
         end
 
+        def add_logger(app)
+          should_warn = true
+          # 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)
+            should_warn = false
+          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)
+            should_warn = false
+          end
+
+          Datadog.logger.warn("Unable to enable Datadog Trace context, Logger #{logger} is not supported") if should_warn
+        end
+
         def patch_after_intialize
           ::ActiveSupport.on_load(:after_initialize) do
             Datadog::Contrib::Rails::Patcher.after_intialize(self)

data/lib/ddtrace/contrib/redis/configuration/resolver.rb

@@ -4,6 +4,8 @@ module Datadog
   module Contrib
     module Redis
       module Configuration
+        UNIX_SCHEME = 'unix'.freeze
+
         # Converts Symbols, Strings, and Hashes to a normalized connection settings Hash.
         class Resolver < Contrib::Configuration::Resolver
           def resolve(key_or_hash)
@@ -13,7 +15,7 @@ module Datadog
           end
 
           def normalize(hash)
-            return { url: hash[:url] } if hash[:scheme] == 'unix'
+            return { url: hash[:url] } if hash[:scheme] == UNIX_SCHEME
 
             # Connexion strings are always converted to host, port, db and scheme
             # but the host, port, db and scheme will generate the :url only after

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

@@ -22,6 +22,11 @@ module Datadog
             o.lazy
           end
 
+          option :command_args do |o|
+            o.default { env_to_bool(Ext::ENV_COMMAND_ARGS, true) }
+            o.lazy
+          end
+
           option :service_name, default: Ext::SERVICE_NAME
         end
       end

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

@@ -9,6 +9,7 @@ module Datadog
         ENV_ANALYTICS_ENABLED_OLD = 'DD_REDIS_ANALYTICS_ENABLED'.freeze
         ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_REDIS_ANALYTICS_SAMPLE_RATE'.freeze
         ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_REDIS_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_COMMAND_ARGS = 'DD_REDIS_COMMAND_ARGS'.freeze
         METRIC_PIPELINE_LEN = 'redis.pipeline_length'.freeze
         SERVICE_NAME = 'redis'.freeze
         SPAN_COMMAND = 'redis.command'.freeze

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

@@ -28,6 +28,7 @@ module Datadog
 
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/BlockLength
+        # rubocop:disable Metrics/AbcSize
         def patch_redis_client
           ::Redis::Client.class_eval do
             alias_method :call_without_datadog, :call
@@ -40,7 +41,7 @@ module Datadog
               pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
                 span.service = pin.service
                 span.span_type = Datadog::Contrib::Redis::Ext::TYPE
-                span.resource = Datadog::Contrib::Redis::Quantize.format_command_args(*args)
+                span.resource = get_command(args)
                 Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
 
                 response = call_without_datadog(*args, &block)
@@ -59,10 +60,10 @@ module Datadog
               pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
                 span.service = pin.service
                 span.span_type = Datadog::Contrib::Redis::Ext::TYPE
-                commands = args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.format_command_args(c) }
+                commands = get_pipeline_commands(args)
                 span.resource = commands.join("\n")
-                Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
                 span.set_metric Datadog::Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
+                Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
 
                 response = call_pipeline_without_datadog(*args, &block)
               end
@@ -84,6 +85,22 @@ module Datadog
 
             private
 
+            def get_command(args)
+              if datadog_configuration[:command_args]
+                Datadog::Contrib::Redis::Quantize.format_command_args(*args)
+              else
+                Datadog::Contrib::Redis::Quantize.get_verb(*args)
+              end
+            end
+
+            def get_pipeline_commands(args)
+              if datadog_configuration[:command_args]
+                args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.format_command_args(c) }
+              else
+                args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.get_verb(c) }
+              end
+            end
+
             def datadog_configuration
               Datadog.configuration[:redis, options]
             end

data/lib/ddtrace/contrib/redis/quantize.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module Datadog
   module Contrib
     module Redis
@@ -8,6 +10,19 @@ module Datadog
         VALUE_MAX_LEN = 50
         CMD_MAX_LEN = 500
 
+        MULTI_VERB_COMMANDS = Set.new(
+          %w[
+            ACL
+            CLIENT
+            CLUSTER
+            COMMAND
+            CONFIG
+            DEBUG
+            LATENCY
+            MEMORY
+          ]
+        ).freeze
+
         module_function
 
         def format_arg(arg)
@@ -27,6 +42,18 @@ module Datadog
           Utils.truncate(cmd, CMD_MAX_LEN, TOO_LONG_MARK)
         end
 
+        def get_verb(command_args)
+          return unless command_args.is_a?(Array)
+
+          return get_verb(command_args.first) if command_args.first.is_a?(Array)
+
+          arg = command_args.first
+          verb = arg.is_a?(Symbol) ? arg.to_s.upcase : arg.to_s
+          return verb unless MULTI_VERB_COMMANDS.include?(verb) && command_args[1]
+
+          "#{verb} #{command_args[1]}"
+        end
+
         def auth_command?(command_args)
           return false unless command_args.is_a?(Array) && !command_args.empty?
           command_args.first.to_sym == :auth

data/lib/ddtrace/contrib/redis/tags.rb

@@ -1,3 +1,4 @@
+require 'ddtrace/ext/integration'
 require 'ddtrace/ext/net'
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/redis/ext'
@@ -9,13 +10,16 @@ module Datadog
       module Tags
         class << self
           def set_common_tags(client, span)
+            # Tag as an external peer service
+            span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
+
             # Set analytics sample rate
             Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
             span.set_tag Datadog::Ext::NET::TARGET_HOST, client.host
             span.set_tag Datadog::Ext::NET::TARGET_PORT, client.port
             span.set_tag Ext::TAG_DB, client.db
-            span.set_tag Ext::TAG_RAW_COMMAND, span.resource
+            span.set_tag Ext::TAG_RAW_COMMAND, span.resource if show_command_args?
           end
 
           private
@@ -31,6 +35,10 @@ module Datadog
           def analytics_sample_rate
             datadog_configuration[:analytics_sample_rate]
           end
+
+          def show_command_args?
+            datadog_configuration[:command_args]
+          end
         end
       end
     end

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

@@ -24,6 +24,7 @@ module Datadog
 
           option :service_name, default: Ext::SERVICE_NAME
           option :workers, default: []
+          option :error_handler, default: Datadog::Tracer::DEFAULT_ON_ERROR
         end
       end
     end

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

@@ -11,7 +11,7 @@ module Datadog
 
         MINIMUM_VERSION = Gem::Version.new('1.0')
         # Maximum is first version it's NOT compatible with (not inclusive)
-        MAXIMUM_VERSION = Gem::Version.new('2.0')
+        MAXIMUM_VERSION = Gem::Version.new('3.0')
 
         register_as :resque, auto_patch: true
 

data/lib/ddtrace/contrib/resque/resque_job.rb

@@ -48,7 +48,7 @@ module Datadog
         end
 
         def span_options
-          { service: datadog_configuration[:service_name] }
+          { service: datadog_configuration[:service_name], on_error: datadog_configuration[:error_handler] }
         end
 
         def tracer