ddtrace 0.13.0 → 0.47.0

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

@@ -5,17 +5,13 @@ require 'ddtrace/contrib/rack/middlewares'
 module Datadog
   # Railtie class initializes
   class Railtie < Rails::Railtie
-    config.app_middleware.insert_before(0, Datadog::Contrib::Rack::TraceMiddleware)
-    # Insert right after Rails exception handling middleware, because if it's before,
-    # it catches and swallows the error. If it's too far after, custom middleware can find itself
-    # between, and raise exceptions that don't end up getting tagged on the request properly (e.g lost stack trace.)
-    config.app_middleware.insert_after(ActionDispatch::ShowExceptions, Datadog::Contrib::Rails::ExceptionMiddleware)
+    # Add the trace middleware to the application stack
+    initializer 'datadog.before_intialize' do |app|
+      Datadog::Contrib::Rails::Patcher.before_intialize(app)
+    end
 
     config.after_initialize do
-      Datadog::Contrib::Rails::Framework.setup
-      Datadog::Contrib::Rails::ActionController.instrument
-      Datadog::Contrib::Rails::ActionView.instrument
-      Datadog::Contrib::Rails::ActiveSupport.instrument
+      Datadog::Contrib::Rails::Patcher.after_intialize(self)
     end
   end
 end

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

@@ -1,46 +1,22 @@
+require 'ddtrace/contrib/analytics'
+
 module Datadog
   module Contrib
     module Rails
       # common utilities for Rails
       module Utils
-        # in Rails the template name includes the template full path
-        # and it's better to avoid storing such information. This method
-        # returns the relative path from `views/` or the template name
-        # if a `views/` folder is not in the template full path. A wrong
-        # usage ensures that this method will not crash the tracing system.
-        def self.normalize_template_name(name)
-          return if name.nil?
-
-          base_path = Datadog.configuration[:rails][:template_base_path]
-          sections_view = name.split(base_path)
-
-          if sections_view.length == 1
-            name.split('/')[-1]
-          else
-            sections_view[-1]
-          end
-        rescue
-          return name.to_s
-        end
-
         def self.app_name
-          if ::Rails::VERSION::MAJOR >= 4
+          if ::Rails::VERSION::MAJOR >= 6
+            ::Rails.application.class.module_parent_name.underscore
+          elsif ::Rails::VERSION::MAJOR >= 4
             ::Rails.application.class.parent_name.underscore
           else
             ::Rails.application.class.to_s.underscore
           end
         end
 
-        def self.exception_is_error?(exception)
-          if defined?(::ActionDispatch::ExceptionWrapper)
-            # Gets the equivalent status code for the exception (not all are 5XX)
-            # You can add custom errors via `config.action_dispatch.rescue_responses`
-            status = ::ActionDispatch::ExceptionWrapper.status_code_for_exception(exception.class.name)
-            # Only 5XX exceptions are actually errors (e.g. don't flag 404s)
-            status.to_s.starts_with?('5')
-          else
-            true
-          end
+        def self.railtie_supported?
+          !(defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR >= 3 && defined?(::Rails::Railtie)).nil?
         end
       end
     end

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

@@ -0,0 +1,31 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/rake/ext'
+
+module Datadog
+  module Contrib
+    module Rake
+      module Configuration
+        # Custom settings for the Rake 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, 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, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
+            o.lazy
+          end
+
+          option :quantize, default: {}
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Datadog
+  module Contrib
+    module Rake
+      # Rake integration constants
+      module Ext
+        APP = 'rake'.freeze
+        ENV_ENABLED = 'DD_TRACE_RAKE_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAKE_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_RAKE_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RAKE_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_RAKE_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'rake'.freeze
+        SPAN_INVOKE = 'rake.invoke'.freeze
+        SPAN_EXECUTE = 'rake.execute'.freeze
+        TAG_EXECUTE_ARGS = 'rake.execute.args'.freeze
+        TAG_INVOKE_ARGS = 'rake.invoke.args'.freeze
+        TAG_TASK_ARG_NAMES = 'rake.task.arg_names'.freeze
+      end
+    end
+  end
+end

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

@@ -1,11 +1,11 @@
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/rake/ext'
+
 module Datadog
   module Contrib
     module Rake
       # Instrumentation for Rake tasks
       module Instrumentation
-        SPAN_NAME_INVOKE = 'rake.invoke'.freeze
-        SPAN_NAME_EXECUTE = 'rake.execute'.freeze
-
         def self.included(base)
           base.send(:prepend, InstanceMethods)
         end
@@ -15,40 +15,56 @@ module Datadog
           def invoke(*args)
             return super unless enabled?
 
-            tracer.trace(SPAN_NAME_INVOKE) do |span|
-              super
+            tracer.trace(Ext::SPAN_INVOKE, span_options) do |span|
               annotate_invoke!(span, args)
+              super
             end
+          ensure
+            shutdown_tracer!
           end
 
           def execute(args = nil)
             return super unless enabled?
 
-            tracer.trace(SPAN_NAME_EXECUTE) do |span|
-              super
+            tracer.trace(Ext::SPAN_EXECUTE, span_options) do |span|
               annotate_execute!(span, args)
+              super
             end
+          ensure
+            shutdown_tracer!
           end
 
           private
 
+          def shutdown_tracer!
+            tracer.shutdown! if tracer.active_span.nil? && ::Rake.application.top_level_tasks.include?(name)
+          end
+
           def annotate_invoke!(span, args)
             span.resource = name
-            span.set_tag('rake.task.arg_names', arg_names)
-            span.set_tag('rake.invoke.args', quantize_args(args)) unless args.nil?
+            # Set analytics sample rate
+            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_TASK_ARG_NAMES, arg_names)
+            span.set_tag(Ext::TAG_INVOKE_ARGS, quantize_args(args)) unless args.nil?
           rescue StandardError => e
-            Datadog::Tracer.log.debug("Error while tracing Rake invoke: #{e.message}")
+            Datadog.logger.debug("Error while tracing Rake invoke: #{e.message}")
           end
 
           def annotate_execute!(span, args)
             span.resource = name
-            span.set_tag('rake.execute.args', quantize_args(args.to_hash)) unless args.nil?
+            span.set_tag(Ext::TAG_EXECUTE_ARGS, quantize_args(args.to_hash)) unless args.nil?
           rescue StandardError => e
-            Datadog::Tracer.log.debug("Error while tracing Rake execute: #{e.message}")
+            Datadog.logger.debug("Error while tracing Rake execute: #{e.message}")
           end
 
           def quantize_args(args)
-            quantize_options = Datadog.configuration[:rake][:quantize][:args]
+            quantize_options = configuration[:quantize][:args]
             Datadog::Quantization::Hash.format(args, quantize_options)
           end
 
@@ -60,6 +76,10 @@ module Datadog
             configuration[:tracer]
           end
 
+          def span_options
+            { service: configuration[:service_name] }
+          end
+
           def configuration
             Datadog.configuration[:rake]
           end

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

@@ -0,0 +1,38 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/rake/configuration/settings'
+require 'ddtrace/contrib/rake/patcher'
+
+module Datadog
+  module Contrib
+    module Rake
+      # Description of Rake integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('12.0')
+
+        register_as :rake
+
+        def self.version
+          Gem.loaded_specs['rake'] && Gem.loaded_specs['rake'].version
+        end
+
+        def self.loaded?
+          !defined?(::Rake::Task).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -1,51 +1,28 @@
+require 'ddtrace/contrib/patcher'
 require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/rake/ext'
 require 'ddtrace/contrib/rake/instrumentation'
 
 module Datadog
   module Contrib
     module Rake
-      # Patcher for Rake instrumentation
+      # Patcher enables patching of 'rake' module.
       module Patcher
-        include Base
-
-        register_as :rake
-        option :service_name, default: 'rake'
-        option :tracer, default: Datadog.tracer
-        option :enabled, default: true
-        option :quantize, default: {}
+        include Contrib::Patcher
 
         module_function
 
-        def patch
-          return patched? if patched? || !compatible?
-
-          patch_rake
-
-          # Set service info
-          configuration[:tracer].set_service_info(
-            configuration[:service_name],
-            'rake',
-            Ext::AppTypes::WORKER
-          )
-
-          @patched = true
+        def target_version
+          Integration.version
         end
 
-        def patched?
-          return @patched if defined?(@patched)
-          @patched = false
-        end
-
-        def patch_rake
+        def patch
+          # Add instrumentation patch to Rake task
           ::Rake::Task.send(:include, Instrumentation)
         end
 
-        def compatible?
-          RUBY_VERSION >= '2.0.0' && defined?(::Rake)
-        end
-
-        def configuration
-          Datadog.configuration[:rake]
+        def get_option(option)
+          Datadog.configuration[:rake].get_option(option)
         end
       end
     end

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

@@ -0,0 +1,45 @@
+require 'ddtrace/contrib/redis/vendor/resolver'
+
+module Datadog
+  module Contrib
+    module Redis
+      module Configuration
+        UNIX_SCHEME = 'unix'.freeze
+
+        # Converts String URLs and Hashes to a normalized connection settings Hash.
+        class Resolver < Contrib::Configuration::Resolver
+          # @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(matcher))
+          end
+
+          def normalize(hash)
+            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
+            # establishing a first connexion
+            {
+              host: hash[:host],
+              port: hash[:port],
+              db: hash[:db],
+              scheme: hash[:scheme]
+            }
+          end
+
+          def connection_resolver
+            @connection_resolver ||= ::Datadog::Contrib::Redis::Vendor::Resolver.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/redis/ext'
+
+module Datadog
+  module Contrib
+    module Redis
+      module Configuration
+        # Custom settings for the Redis 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, 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, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
+            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
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Datadog
+  module Contrib
+    module Redis
+      # Redis integration constants
+      module Ext
+        APP = 'redis'.freeze
+        ENV_ENABLED = 'DD_TRACE_REDIS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_REDIS_ANALYTICS_ENABLED'.freeze
+        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
+        TAG_DB = 'out.redis_db'.freeze
+        TAG_RAW_COMMAND = 'redis.raw_command'.freeze
+        TYPE = 'redis'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/redis/configuration/settings'
+require 'ddtrace/contrib/redis/patcher'
+
+module Datadog
+  module Contrib
+    module Redis
+      # Description of Redis integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('3.2')
+
+        register_as :redis, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['redis'] && Gem.loaded_specs['redis'].version
+        end
+
+        def self.loaded?
+          !defined?(::Redis).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+
+        def resolver
+          @resolver ||= Configuration::Resolver.new
+        end
+      end
+    end
+  end
+end