ddtrace 0.13.2 → 0.14.0.beta1

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

@@ -0,0 +1,35 @@
+require 'ddtrace/contrib/configuration/options'
+
+module Datadog
+  module Contrib
+    module Configuration
+      # Common settings for all integrations
+      class Settings
+        include Options
+
+        option :service_name
+        option :tracer, default: Datadog.tracer
+
+        def initialize(options = {})
+          configure(options)
+        end
+
+        def configure(options = {})
+          self.class.options.dependency_order.each do |name|
+            self[name] = options.fetch(name, self[name])
+          end
+
+          yield(self) if block_given?
+        end
+
+        def [](name)
+          respond_to?(name) ? send(name) : get_option(name)
+        end
+
+        def []=(name, value)
+          respond_to?("#{name}=") ? send("#{name}=", value) : set_option(name, value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Datadog
+  module Contrib
+    module DelayedJob
+      # DelayedJob integration
+      module Patcher
+        include Base
+        register_as :delayed_job
+
+        option :service_name, default: 'delayed_job'.freeze
+        option :tracer, default: Datadog.tracer
+
+        @patched = false
+
+        class << self
+          def patch
+            return @patched if patched? || !defined?(::Delayed)
+
+            require 'ddtrace/ext/app_types'
+            require_relative 'plugin'
+
+            add_instrumentation(::Delayed::Worker)
+            @patched = true
+          rescue => e
+            Tracer.log.error("Unable to apply DelayedJob integration: #{e}")
+            @patched
+          end
+
+          def patched?
+            @patched
+          end
+
+          private
+
+          def add_instrumentation(klass)
+            klass.plugins << Plugin
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/delayed_job/plugin.rb

@@ -0,0 +1,43 @@
+require 'delayed/plugin'
+
+module Datadog
+  module Contrib
+    module DelayedJob
+      # DelayedJob plugin that instruments invoke_job hook
+      class Plugin < Delayed::Plugin
+        def self.instrument(job, &block)
+          return block.call(job) unless tracer && tracer.enabled
+
+          tracer.trace('delayed_job'.freeze, service: configuration[:service_name], resource: job.name) do |span|
+            span.set_tag('delayed_job.id'.freeze, job.id)
+            span.set_tag('delayed_job.queue'.freeze, job.queue) if job.queue
+            span.set_tag('delayed_job.priority'.freeze, job.priority)
+            span.set_tag('delayed_job.attempts'.freeze, job.attempts)
+            span.span_type = Ext::AppTypes::WORKER
+
+            yield job
+          end
+        end
+
+        def self.flush(worker, &block)
+          yield worker
+
+          tracer.shutdown! if tracer && tracer.enabled
+        end
+
+        def self.configuration
+          Datadog.configuration[:delayed_job]
+        end
+
+        def self.tracer
+          configuration[:tracer]
+        end
+
+        callbacks do |lifecycle|
+          lifecycle.around(:invoke_job, &method(:instrument))
+          lifecycle.around(:execute, &method(:flush))
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/integration.rb

@@ -0,0 +1,16 @@
+require 'ddtrace/contrib/configurable'
+require 'ddtrace/contrib/patchable'
+require 'ddtrace/contrib/registerable'
+
+module Datadog
+  module Contrib
+    # Base provides features that are shared across all integrations
+    module Integration
+      def self.included(base)
+        base.send(:include, Configurable)
+        base.send(:include, Patchable)
+        base.send(:include, Registerable)
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/patchable.rb

@@ -0,0 +1,38 @@
+module Datadog
+  module Contrib
+    # Base provides features that are shared across all integrations
+    module Patchable
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Class methods for integrations
+      module ClassMethods
+        def version
+          nil
+        end
+
+        def present?
+          !version.nil?
+        end
+
+        def compatible?
+          RUBY_VERSION >= '1.9.3' && present?
+        end
+      end
+
+      # Instance methods for integrations
+      module InstanceMethods
+        def patcher
+          nil
+        end
+
+        def patch
+          return if !self.class.compatible? || patcher.nil?
+          patcher.patch
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/patcher.rb

@@ -0,0 +1,28 @@
+require 'ddtrace/patcher'
+
+module Datadog
+  module Contrib
+    # Common behavior for patcher modules
+    module Patcher
+      def self.included(base)
+        base.send(:include, Datadog::Patcher)
+        base.send(:extend, InstanceMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Class methods for patchers
+      module ClassMethods
+        def patch
+          raise NotImplementedError, '#patch not implemented for Patcher!'
+        end
+      end
+
+      # Instance methods for patchers
+      module InstanceMethods
+        def patch
+          raise NotImplementedError, '#patch not implemented for Patcher!'
+        end
+      end
+    end
+  end
+end

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

@@ -15,31 +15,23 @@ module Datadog
           def invoke(*args)
             return super unless enabled?
 
-            tracer.trace(SPAN_NAME_INVOKE, span_options) do |span|
+            tracer.trace(SPAN_NAME_INVOKE) do |span|
               super
               annotate_invoke!(span, args)
             end
-          ensure
-            shutdown_tracer!
           end
 
           def execute(args = nil)
             return super unless enabled?
 
-            tracer.trace(SPAN_NAME_EXECUTE, span_options) do |span|
+            tracer.trace(SPAN_NAME_EXECUTE) do |span|
               super
               annotate_execute!(span, args)
             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)
@@ -56,7 +48,7 @@ module Datadog
           end
 
           def quantize_args(args)
-            quantize_options = configuration[:quantize][:args]
+            quantize_options = Datadog.configuration[:rake][:quantize][:args]
             Datadog::Quantization::Hash.format(args, quantize_options)
           end
 
@@ -68,10 +60,6 @@ module Datadog
             configuration[:tracer]
           end
 
-          def span_options
-            { service: configuration[:service_name] }
-          end
-
           def configuration
             Datadog.configuration[:rake]
           end

data/lib/ddtrace/contrib/registerable.rb

@@ -0,0 +1,33 @@
+require 'ddtrace/registry'
+
+module Datadog
+  module Contrib
+    # Defines registerable behavior for integrations
+    module Registerable
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Class methods for registerable behavior
+      module ClassMethods
+        def register_as(name, options = {})
+          registry = options.fetch(:registry, Datadog.registry)
+          auto_patch = options.fetch(:auto_patch, false)
+
+          registry.add(name, new(name, options), auto_patch)
+        end
+      end
+
+      # Instance methods for registerable behavior
+      module InstanceMethods
+        attr_reader \
+          :name
+
+        def initialize(name, options = {})
+          @name = name
+        end
+      end
+    end
+  end
+end

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

@@ -16,26 +16,18 @@ module Datadog
             yield
             span.service = pin.service
           end
+        ensure
+          pin.tracer.shutdown! if pin && pin.tracer
         end
       end
     end
   end
 end
 
-Resque.before_first_fork do
-  pin = Datadog::Pin.get_from(Resque)
-  next unless pin && pin.tracer
-
-  # Create SyncWriter instance before forking
-  sync_writer = Datadog::SyncWriter.new(transport: pin.tracer.writer.transport)
-  Datadog::Contrib::Resque.sync_writer = sync_writer
-end
-
 Resque.after_fork do
   # get the current tracer
   pin = Datadog::Pin.get_from(Resque)
   next unless pin && pin.tracer
   # clean the state so no CoW happens
   pin.tracer.provider.context = nil
-  pin.tracer.writer = Datadog::Contrib::Resque.sync_writer
 end

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

@@ -0,0 +1,13 @@
+require 'ddtrace/contrib/configuration/settings'
+
+module Datadog
+  module Contrib
+    module Sequel
+      module Configuration
+        class Settings < Contrib::Configuration::Settings
+          # Add any custom Sequel settings or behavior here.
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sequel/database.rb

@@ -31,7 +31,7 @@ module Datadog
           def datadog_pin
             @pin ||= Datadog::Pin.new(
               Datadog.configuration[:sequel][:service_name] || adapter_name,
-              app: Patcher::APP,
+              app: Integration::APP,
               app_type: Datadog::Ext::AppTypes::DB,
               tracer: Datadog.configuration[:sequel][:tracer] || Datadog.tracer
             )

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

@@ -0,0 +1,38 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/sequel/configuration/settings'
+require 'ddtrace/contrib/sequel/patcher'
+
+module Datadog
+  module Contrib
+    module Sequel
+      # Description of Sequel integration
+      class Integration
+        include Contrib::Integration
+
+        APP = 'sequel'.freeze
+
+        register_as :sequel, auto_patch: false
+
+        def self.version
+          Gem.loaded_specs['sequel'] && Gem.loaded_specs['sequel'].version
+        end
+
+        def self.present?
+          super && defined?(::Sequel)
+        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/sequel/patcher.rb

@@ -1,3 +1,4 @@
+require 'ddtrace/contrib/patcher'
 require 'ddtrace/contrib/sequel/database'
 require 'ddtrace/contrib/sequel/dataset'
 
@@ -7,40 +8,23 @@ module Datadog
       # Patcher enables patching of 'sequel' module.
       # This is used in monkey.rb to manually apply patches
       module Patcher
-        include Base
-
-        APP = 'sequel'.freeze
-
-        register_as :sequel, auto_patch: false
-        option :service_name
-        option :tracer, default: Datadog.tracer
-
-        @patched = false
+        include Contrib::Patcher
 
         module_function
 
-        # patched? tells whether patch has been successfully applied
         def patched?
-          @patched
+          done?(:sequel)
         end
 
         def patch
-          if !@patched && compatible?
+          do_once(:sequel) do
             begin
               patch_sequel_database
               patch_sequel_dataset
-
-              @patched = true
             rescue StandardError => e
               Datadog::Tracer.log.error("Unable to apply Sequel integration: #{e}")
             end
           end
-
-          @patched
-        end
-
-        def compatible?
-          RUBY_VERSION >= '2.0.0' && defined?(::Sequel)
         end
 
         def patch_sequel_database

data/lib/ddtrace/patcher.rb

@@ -32,6 +32,11 @@ module Datadog
           @done_once[key] = true
         end
       end
+
+      def done?(key)
+        return false unless instance_variable_defined?(:@done_once)
+        !@done_once.nil? && @done_once.key?(key)
+      end
     end
 
     # Extend the common methods so they're available as a module function.