ddtrace 0.13.0 → 0.47.0

data/lib/ddtrace/contrib/registerable.rb

@@ -0,0 +1,33 @@
+require 'ddtrace/contrib/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/registry.rb

@@ -0,0 +1,42 @@
+module Datadog
+  module Contrib
+    # Registry is a collection of integrations.
+    class Registry
+      include Enumerable
+
+      Entry = Struct.new(:name, :klass, :auto_patch)
+
+      def initialize
+        @data = {}
+        @mutex = Mutex.new
+      end
+
+      def add(name, klass, auto_patch = false)
+        @mutex.synchronize do
+          @data[name] = Entry.new(name, klass, auto_patch).freeze
+        end
+      end
+
+      def each(&block)
+        @mutex.synchronize do
+          @data.each_value(&block)
+        end
+      end
+
+      def [](name)
+        @mutex.synchronize do
+          entry = @data[name]
+          entry.klass if entry
+        end
+      end
+
+      def to_h
+        @mutex.synchronize do
+          @data.each_with_object({}) do |(_, entry), hash|
+            hash[entry.name] = entry.auto_patch
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+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 :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 :service_name, default: Ext::SERVICE_NAME
+          option :workers, default: []
+          option :error_handler, default: Datadog::Tracer::DEFAULT_ON_ERROR
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Datadog
+  module Contrib
+    module Resque
+      # Resque integration constants
+      module Ext
+        APP = 'resque'.freeze
+        ENV_ENABLED = 'DD_TRACE_RESQUE_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_RESQUE_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_RESQUE_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RESQUE_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_RESQUE_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'resque'.freeze
+        SPAN_JOB = 'resque.job'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/resque/configuration/settings'
+require 'ddtrace/contrib/resque/patcher'
+
+module Datadog
+  module Contrib
+    module Resque
+      # Description of Resque integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('1.0')
+        # Maximum is first version it's NOT compatible with (not inclusive)
+        MAXIMUM_VERSION = Gem::Version.new('3.0')
+
+        register_as :resque, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['resque'] && Gem.loaded_specs['resque'].version
+        end
+
+        def self.loaded?
+          !defined?(::Resque).nil?
+        end
+
+        def self.compatible?
+          super \
+            && version >= MINIMUM_VERSION \
+            && version < MAXIMUM_VERSION
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+
+        class << self
+          # Globally-acccesible reference for pre-forking optimization
+          attr_accessor :sync_writer
+        end
+      end
+    end
+  end
+end

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

@@ -1,49 +1,27 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/sidekiq/ext'
+
 module Datadog
   module Contrib
-    # Namespace for `resque` integration
     module Resque
-      SERVICE = 'resque'.freeze
-
-      class << self
-        # Globally-acccesible reference for pre-forking optimization
-        attr_accessor :sync_writer
-      end
-
-      # Patcher for Resque integration - sets up the pin for the integration
+      # Patcher enables patching of 'resque' module.
       module Patcher
-        include Base
-        register_as :resque, auto_patch: true
-        option :service_name, default: SERVICE
-
-        @patched = false
-        option :workers, default: []
+        include Contrib::Patcher
 
-        class << self
-          def patch
-            return @patched if patched? || !defined?(::Resque)
+        module_function
 
-            require 'ddtrace/ext/app_types'
-            require_relative 'resque_job'
-
-            add_pin
-            get_option(:workers).each { |worker| worker.extend(ResqueJob) }
-            @patched = true
-          rescue => e
-            Tracer.log.error("Unable to apply Resque integration: #{e}")
-            @patched
-          end
-
-          def patched?
-            @patched
-          end
+        def target_version
+          Integration.version
+        end
 
-          private
+        def patch
+          require_relative 'resque_job'
+          get_option(:workers).each { |worker| worker.extend(ResqueJob) }
+        end
 
-          def add_pin
-            Pin
-              .new(get_option(:service_name), app: 'resque', app_type: Ext::AppTypes::WORKER)
-              .onto(::Resque)
-          end
+        def get_option(option)
+          Datadog.configuration[:resque].get_option(option)
         end
       end
     end

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

@@ -1,5 +1,7 @@
 require 'ddtrace/ext/app_types'
 require 'ddtrace/sync_writer'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/sidekiq/ext'
 require 'resque'
 
 module Datadog
@@ -8,34 +10,73 @@ module Datadog
       # Uses Resque job hooks to create traces
       module ResqueJob
         def around_perform(*args)
-          pin = Pin.get_from(::Resque)
-          return yield unless pin && pin.tracer
-          pin.tracer.trace('resque.job', service: pin.service) do |span|
-            span.resource = name
-            span.span_type = pin.app_type
+          return yield unless datadog_configuration && tracer
+
+          tracer.trace(Ext::SPAN_JOB, span_options) do |span|
+            span.resource = args.first.is_a?(Hash) && args.first['job_class'] || name
+            span.span_type = Datadog::Ext::AppTypes::WORKER
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])
+            end
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
             yield
-            span.service = pin.service
           end
         end
+
+        def after_perform_shutdown_tracer(*_)
+          shutdown_tracer_when_forked!
+        end
+
+        def on_failure_shutdown_tracer(*_)
+          shutdown_tracer_when_forked!
+        end
+
+        def shutdown_tracer_when_forked!
+          tracer.shutdown! if forked?
+        end
+
+        private
+
+        def forked?
+          pin = Datadog::Pin.get_from(::Resque)
+          return false unless pin
+
+          pin.config[:forked] == true
+        end
+
+        def span_options
+          { service: datadog_configuration[:service_name], on_error: datadog_configuration[:error_handler] }
+        end
+
+        def tracer
+          datadog_configuration.tracer
+        end
+
+        def datadog_configuration
+          Datadog.configuration[:resque]
+        end
       end
     end
   end
 end
 
-Resque.before_first_fork do
-  pin = Datadog::Pin.get_from(Resque)
-  next unless pin && pin.tracer
+Resque.after_fork do
+  configuration = Datadog.configuration[:resque]
+  next if configuration.nil?
 
-  # Create SyncWriter instance before forking
-  sync_writer = Datadog::SyncWriter.new(transport: pin.tracer.writer.transport)
-  Datadog::Contrib::Resque.sync_writer = sync_writer
-end
+  # Add a pin, marking the job as forked.
+  # Used to trigger shutdown in forks for performance reasons.
+  Datadog::Pin.new(
+    configuration[:service_name],
+    config: { forked: true }
+  ).onto(::Resque)
 
-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
+  # Clean the state so no CoW happens
+  next if configuration[:tracer].nil?
+
+  configuration[:tracer].provider.context = nil
 end

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

@@ -0,0 +1,31 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/rest_client/ext'
+
+module Datadog
+  module Contrib
+    module RestClient
+      module Configuration
+        # Custom settings for the RestClient 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 :distributed_tracing, default: true
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Datadog
+  module Contrib
+    module RestClient
+      # RestClient integration constants
+      module Ext
+        APP = 'rest_client'.freeze
+        ENV_ENABLED = 'DD_TRACE_REST_CLIENT_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_REST_CLIENT_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_REST_CLIENT_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_REST_CLIENT_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_REST_CLIENT_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'rest_client'.freeze
+        SPAN_REQUEST = 'rest_client.request'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/rest_client/configuration/settings'
+require 'ddtrace/contrib/rest_client/patcher'
+
+module Datadog
+  module Contrib
+    module RestClient
+      # Description of RestClient integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('1.8')
+
+        register_as :rest_client
+
+        def self.version
+          Gem.loaded_specs['rest-client'] && Gem.loaded_specs['rest-client'].version
+        end
+
+        def self.loaded?
+          !defined?(::RestClient::Request).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/rest_client/patcher.rb

@@ -0,0 +1,23 @@
+module Datadog
+  module Contrib
+    module RestClient
+      # Patcher enables patching of 'rest_client' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          require 'ddtrace/ext/app_types'
+          require 'ddtrace/contrib/rest_client/request_patch'
+
+          ::RestClient::Request.send(:include, RequestPatch)
+        end
+      end
+    end
+  end
+end