ddtrace 0.16.1 → 0.17.0

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

@@ -6,19 +6,12 @@ module Datadog
   # Railtie class initializes
   class Railtie < Rails::Railtie
     # Add the trace middleware to the application stack
-    initializer 'datadog.add_middleware' do |app|
-      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.)
-      app.middleware.insert_after(ActionDispatch::ShowExceptions, Datadog::Contrib::Rails::ExceptionMiddleware)
+    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/rake/configuration/settings.rb

@@ -0,0 +1,17 @@
+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, default: true
+          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,18 @@
+module Datadog
+  module Contrib
+    module Rake
+      # Rake integration constants
+      module Ext
+        APP = 'rake'.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,10 @@
+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,7 +14,7 @@ module Datadog
           def invoke(*args)
             return super unless enabled?
 
-            tracer.trace(SPAN_NAME_INVOKE, span_options) do |span|
+            tracer.trace(Ext::SPAN_INVOKE, span_options) do |span|
               super
               annotate_invoke!(span, args)
             end
@@ -26,7 +25,7 @@ module Datadog
           def execute(args = nil)
             return super unless enabled?
 
-            tracer.trace(SPAN_NAME_EXECUTE, span_options) do |span|
+            tracer.trace(Ext::SPAN_EXECUTE, span_options) do |span|
               super
               annotate_execute!(span, args)
             end
@@ -42,15 +41,15 @@ module Datadog
 
           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?
+            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}")
           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}")
           end

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

@@ -0,0 +1,36 @@
+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
+
+        register_as :rake
+
+        def self.version
+          Gem.loaded_specs['rake'] && Gem.loaded_specs['rake'].version
+        end
+
+        def self.present?
+          super && defined?(::Rake)
+        end
+
+        def self.compatible?
+          super && RUBY_VERSION >= '2.0.0'
+        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,41 @@
+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
-        end
-
         def patched?
-          return @patched if defined?(@patched)
-          @patched = false
+          done?(:rake)
         end
 
-        def patch_rake
-          ::Rake::Task.send(:include, Instrumentation)
-        end
-
-        def compatible?
-          RUBY_VERSION >= '2.0.0' && defined?(::Rake)
+        def patch
+          do_once(:rake) do
+            begin
+              # Add instrumentation patch to Rake task
+              ::Rake::Task.send(:include, Instrumentation)
+
+              # Set service info
+              get_option(:tracer).set_service_info(
+                get_option(:service_name),
+                Ext::APP,
+                Datadog::Ext::AppTypes::WORKER
+              )
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Rake integration: #{e}")
+            end
+          end
         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/settings.rb

@@ -0,0 +1,15 @@
+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 :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Datadog
+  module Contrib
+    module Redis
+      # Redis integration constants
+      module Ext
+        APP = 'redis'.freeze
+        SERVICE_NAME = 'redis'.freeze
+        TYPE = 'redis'.freeze
+
+        METRIC_PIPELINE_LEN = 'redis.pipeline_length'.freeze
+
+        SPAN_COMMAND = 'redis.command'.freeze
+
+        TAG_DB = 'out.redis_db'.freeze
+        TAG_RAW_COMMAND = 'redis.raw_command'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+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
+
+        register_as :redis, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['redis'] && Gem.loaded_specs['redis'].version
+        end
+
+        def self.present?
+          super && defined?(::Redis)
+        end
+
+        def self.compatible?
+          !version.nil? && version >= Gem::Version.new('3.0.0')
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -1,43 +1,35 @@
-# requirements should be kept minimal as Patcher is a shared requirement.
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/redis/ext'
 
 module Datadog
   module Contrib
     module Redis
-      SERVICE = 'redis'.freeze
-      DRIVER = 'redis.driver'.freeze
-
       # Patcher enables patching of 'redis' module.
       module Patcher
-        include Base
-        register_as :redis, auto_patch: true
-        option :service_name, default: SERVICE
-        option :tracer, default: Datadog.tracer
-
-        @patched = false
+        include Contrib::Patcher
 
         module_function
 
+        def patched?
+          done?(:redis)
+        end
+
         # patch applies our patch if needed
         def patch
-          if !@patched && compatible?
+          do_once(:redis) do
             begin
               # do not require these by default, but only when actually patching
+              require 'redis'
               require 'ddtrace/ext/app_types'
               require 'ddtrace/contrib/redis/tags'
               require 'ddtrace/contrib/redis/quantize'
 
               patch_redis_client
-              @patched = true
-              RailsCachePatcher.reload_cache_store if Datadog.registry[:rails].patched?
+              RailsCachePatcher.reload_cache_store if Datadog.registry[:rails].patcher.patched?
             rescue StandardError => e
               Datadog::Tracer.log.error("Unable to apply Redis integration: #{e}")
             end
           end
-          @patched
-        end
-
-        def compatible?
-          defined?(::Redis::VERSION) && Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('3.0.0')
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -52,7 +44,12 @@ module Datadog
             def initialize(*args)
               service = Datadog.configuration[:redis][:service_name]
               tracer = Datadog.configuration[:redis][:tracer]
-              pin = Datadog::Pin.new(service, app: 'redis', app_type: Datadog::Ext::AppTypes::DB, tracer: tracer)
+              pin = Datadog::Pin.new(
+                service,
+                app: Ext::APP,
+                app_type: Datadog::Ext::AppTypes::DB,
+                tracer: tracer
+              )
               pin.onto(self)
               initialize_without_datadog(*args)
             end
@@ -64,9 +61,9 @@ module Datadog
               return call_without_datadog(*args, &block) unless pin && pin.tracer
 
               response = nil
-              pin.tracer.trace('redis.command') do |span|
+              pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
                 span.service = pin.service
-                span.span_type = Datadog::Ext::Redis::TYPE
+                span.span_type = Datadog::Contrib::Redis::Ext::TYPE
                 span.resource = Datadog::Contrib::Redis::Quantize.format_command_args(*args)
                 Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
 
@@ -83,13 +80,13 @@ module Datadog
               return call_pipeline_without_datadog(*args, &block) unless pin && pin.tracer
 
               response = nil
-              pin.tracer.trace('redis.command') do |span|
+              pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
                 span.service = pin.service
-                span.span_type = Datadog::Ext::Redis::TYPE
+                span.span_type = Datadog::Contrib::Redis::Ext::TYPE
                 commands = args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.format_command_args(c) }
                 span.resource = commands.join("\n")
                 Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
-                span.set_metric Datadog::Ext::Redis::PIPELINE_LEN, commands.length
+                span.set_metric Datadog::Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
 
                 response = call_pipeline_without_datadog(*args, &block)
               end
@@ -98,11 +95,6 @@ module Datadog
             end
           end
         end
-
-        # patched? tells wether patch has been successfully applied
-        def patched?
-          @patched
-        end
       end
     end
   end

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

@@ -1,5 +1,5 @@
 require 'ddtrace/ext/net'
-require 'ddtrace/ext/redis'
+require 'ddtrace/contrib/redis/ext'
 
 module Datadog
   module Contrib
@@ -11,8 +11,8 @@ module Datadog
         def set_common_tags(client, span)
           span.set_tag Datadog::Ext::NET::TARGET_HOST, client.host
           span.set_tag Datadog::Ext::NET::TARGET_PORT, client.port
-          span.set_tag Datadog::Ext::Redis::DB, client.db
-          span.set_tag Datadog::Ext::Redis::RAW_COMMAND, span.resource
+          span.set_tag Ext::TAG_DB, client.db
+          span.set_tag Ext::TAG_RAW_COMMAND, span.resource
         end
       end
     end

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

@@ -0,0 +1,16 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/resque/ext'
+
+module Datadog
+  module Contrib
+    module Resque
+      module Configuration
+        # Custom settings for the Resque integration
+        class Settings < Contrib::Configuration::Settings
+          option :service_name, default: Ext::SERVICE_NAME
+          option :workers, default: []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Datadog
+  module Contrib
+    module Resque
+      # Resque integration constants
+      module Ext
+        APP = 'resque'.freeze
+        SERVICE_NAME = 'resque'.freeze
+
+        SPAN_JOB = 'resque.job'.freeze
+      end
+    end
+  end
+end