ddtrace 0.40.0 → 0.50.0

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

@@ -53,9 +53,7 @@ module Datadog
             end
           end
 
-          following = if middleware.instance_variable_defined?('@app')
-                        middleware.instance_variable_get('@app')
-                      end
+          following = (middleware.instance_variable_get('@app') if middleware.instance_variable_defined?('@app'))
 
           retain_middleware_name(following)
         end

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

@@ -1,7 +1,12 @@
 module Datadog
   module Contrib
     module Rack
-      # QueueTime simply...
+      # Retrieves the time spent in an upstream proxy
+      # for the current Rack request.
+      #
+      # This time captures the request delay introduced but
+      # such proxy before the request made it to the Ruby
+      # process.
       module QueueTime
         REQUEST_START = 'HTTP_X_REQUEST_START'.freeze
         QUEUE_START = 'HTTP_X_QUEUE_START'.freeze

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

@@ -0,0 +1,10 @@
+require 'ddtrace'
+
+# Railtie to include AutoInstrumentation in rails loading
+class DatadogAutoInstrumentRailtie < Rails::Railtie
+  # we want to load before config initializers so that any user supplied config
+  # in config/initializers/datadog.rb will take precedence
+  initializer 'datadog.start_tracer', before: :load_config_initializers do
+    Datadog::Contrib::AutoInstrument.patch_all
+  end
+end

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

@@ -3,6 +3,7 @@ require 'ddtrace/contrib/rails/framework'
 require 'ddtrace/contrib/rails/middlewares'
 require 'ddtrace/contrib/rails/log_injection'
 require 'ddtrace/contrib/rack/middlewares'
+require 'ddtrace/utils/only_once'
 
 module Datadog
   module Contrib
@@ -11,6 +12,9 @@ module Datadog
       module Patcher
         include Contrib::Patcher
 
+        BEFORE_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Datadog::Utils::OnlyOnce.new }
+        AFTER_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Datadog::Utils::OnlyOnce.new }
+
         module_function
 
         def target_version
@@ -29,7 +33,7 @@ module Datadog
         end
 
         def before_intialize(app)
-          do_once(:rails_before_initialize, for: app) do
+          BEFORE_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
             # Middleware must be added before the application is initialized.
             # Otherwise the middleware stack will be frozen.
             # Sometimes we don't want to activate middleware e.g. OpenTracing, etc.
@@ -53,16 +57,30 @@ module Datadog
         end
 
         def add_logger(app)
+          should_warn = true
           # check if lograge key exists
-          if app.config.respond_to?(:lograge) && app.config.lograge.enabled
+          # 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)
-          # if lograge isn't set, check if tagged logged is enabed.
+            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.
-          elsif (logger = app.config.logger) && logger.is_a?(::ActiveSupport::TaggedLogging)
+          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("Unabe to enable Datadog Trace context, Logger #{logger} is not supported")
+            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
@@ -72,7 +90,7 @@ module Datadog
         end
 
         def after_intialize(app)
-          do_once(:rails_after_initialize, for: app) do
+          AFTER_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
             # Finish configuring the tracer after the application is initialized.
             # We need to wait for some things, like application name, middleware stack, etc.
             setup_tracer

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

@@ -14,6 +14,10 @@ module Datadog
             ::Rails.application.class.to_s.underscore
           end
         end
+
+        def self.railtie_supported?
+          !(defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR >= 3 && defined?(::Rails::Railtie)).nil?
+        end
       end
     end
   end

data/lib/ddtrace/contrib/rake/instrumentation.rb

@@ -7,7 +7,7 @@ module Datadog
       # Instrumentation for Rake tasks
       module Instrumentation
         def self.included(base)
-          base.send(:prepend, InstanceMethods)
+          base.prepend(InstanceMethods)
         end
 
         # Instance methods for Rake instrumentation
@@ -16,7 +16,8 @@ module Datadog
             return super unless enabled?
 
             tracer.trace(Ext::SPAN_INVOKE, span_options) do |span|
-              super.tap { annotate_invoke!(span, args) }
+              annotate_invoke!(span, args)
+              super
             end
           ensure
             shutdown_tracer!
@@ -26,7 +27,8 @@ module Datadog
             return super unless enabled?
 
             tracer.trace(Ext::SPAN_EXECUTE, span_options) do |span|
-              super.tap { annotate_execute!(span, args) }
+              annotate_execute!(span, args)
+              super
             end
           ensure
             shutdown_tracer!

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

@@ -18,7 +18,7 @@ module Datadog
         end
 
         def self.loaded?
-          !defined?(::Rake).nil?
+          !defined?(::Rake::Task).nil?
         end
 
         def self.compatible?

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

@@ -18,7 +18,7 @@ module Datadog
 
         def patch
           # Add instrumentation patch to Rake task
-          ::Rake::Task.send(:include, Instrumentation)
+          ::Rake::Task.include(Instrumentation)
         end
 
         def get_option(option)

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

@@ -4,16 +4,25 @@ module Datadog
   module Contrib
     module Redis
       module Configuration
-        # Converts Symbols, Strings, and Hashes to a normalized connection settings Hash.
+        UNIX_SCHEME = 'unix'.freeze
+
+        # Converts String URLs and Hashes to a normalized connection settings Hash.
         class Resolver < Contrib::Configuration::Resolver
-          def resolve(key_or_hash)
-            return :default if key_or_hash == :default
+          # @param [Hash,String] Redis connection information
+          def resolve(hash)
+            super(parse_matcher(hash))
+          end
+
+          protected
+
+          def parse_matcher(matcher)
+            matcher = { url: matcher } if matcher.is_a?(String)
 
-            normalize(connection_resolver.resolve(key_or_hash))
+            normalize(connection_resolver.resolve(matcher))
           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,8 +42,21 @@ 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
         end
 

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/redis/vendor/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Ezra Zygmuntowicz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

@@ -56,11 +56,9 @@ module Datadog
             defaults = DEFAULTS.dup
             options = options.dup
 
-            defaults.keys.each do |key|
+            defaults.each_key do |key|
               # Fill in defaults if needed
-              if defaults[key].respond_to?(:call)
-                defaults[key] = defaults[key].call
-              end
+              defaults[key] = defaults[key].call if defaults[key].respond_to?(:call)
 
               # Symbolize only keys that are needed
               options[key] = options[key.to_s] if options.key?(key.to_s)
@@ -73,9 +71,10 @@ module Datadog
             if url
               uri = URI(url)
 
-              if uri.scheme == 'unix'
+              case uri.scheme
+              when 'unix'
                 defaults[:path] = uri.path
-              elsif uri.scheme == 'redis' || uri.scheme == 'rediss'
+              when 'redis', 'rediss'
                 defaults[:scheme]   = uri.scheme
                 defaults[:host]     = uri.host if uri.host
                 defaults[:port]     = uri.port if uri.port
@@ -90,7 +89,7 @@ module Datadog
             end
 
             # Use default when option is not specified or nil
-            defaults.keys.each do |key|
+            defaults.each_key do |key|
               options[key] = defaults[key] if options[key].nil?
             end
 

data/lib/ddtrace/contrib/registerable.rb

@@ -5,8 +5,8 @@ module Datadog
     # Defines registerable behavior for integrations
     module Registerable
       def self.included(base)
-        base.send(:extend, ClassMethods)
-        base.send(:include, InstanceMethods)
+        base.extend(ClassMethods)
+        base.include(InstanceMethods)
       end
 
       # Class methods for registerable behavior

data/lib/ddtrace/contrib/registry.rb

@@ -17,9 +17,9 @@ module Datadog
         end
       end
 
-      def each
+      def each(&block)
         @mutex.synchronize do
-          @data.each { |_, entry| yield(entry) }
+          @data.each_value(&block)
         end
       end
 

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

@@ -23,7 +23,24 @@ module Datadog
           end
 
           option :service_name, default: Ext::SERVICE_NAME
-          option :workers, default: []
+
+          # A list Ruby worker classes to be instrumented.
+          # The value of `nil` has special semantics: it instruments all workers dynamically.
+          #
+          # TODO: 1.0: Automatic patching should be the default behavior.
+          # We should not provide this option in the future,
+          # as our integrations should always instrument all possible scenarios when feasible.
+          option :workers, default: nil do |o|
+            o.on_set do |value|
+              unless value.nil?
+                Datadog.logger.warn(
+                  "DEPRECATED: Resque integration now instruments all workers. \n" \
+                  'The `workers:` option is unnecessary and will be removed in the future.'
+                )
+              end
+            end
+          end
+          option :error_handler, default: Datadog::Tracer::DEFAULT_ON_ERROR
         end
       end
     end