ddtrace 0.13.0 → 0.14.0

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

@@ -15,23 +15,31 @@ module Datadog
           def invoke(*args)
             return super unless enabled?
 
-            tracer.trace(SPAN_NAME_INVOKE) do |span|
+            tracer.trace(SPAN_NAME_INVOKE, span_options) 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) do |span|
+            tracer.trace(SPAN_NAME_EXECUTE, span_options) 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)
@@ -48,7 +56,7 @@ module Datadog
           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 +68,10 @@ 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/rest_client/configuration/settings.rb

@@ -0,0 +1,22 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/active_record/utils'
+
+module Datadog
+  module Contrib
+    module RestClient
+      module Configuration
+        # Unique settings for RestClient
+        class Settings < Contrib::Configuration::Settings
+          NAME = 'rest_client'.freeze
+
+          option :service_name, default: NAME, depends_on: [:tracer] do |value|
+            get_option(:tracer).set_service_info(value, NAME, Ext::AppTypes::DB)
+            value
+          end
+
+          option :distributed_tracing, default: false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+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
+        register_as :rest_client
+
+        def self.compatible?
+          RUBY_VERSION >= '1.9.3' && defined?(::RestClient::Request)
+        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,25 @@
+module Datadog
+  module Contrib
+    module RestClient
+      # RestClient integration
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:rest_client)
+        end
+
+        def patch
+          do_once(:rest_client) do
+            require 'ddtrace/ext/app_types'
+            require 'ddtrace/contrib/rest_client/request_patch'
+
+            ::RestClient::Request.send(:include, RequestPatch)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/distributed'
+require 'ddtrace/propagation/http_propagator'
+
+module Datadog
+  module Contrib
+    module RestClient
+      # RestClient RequestPatch
+      module RequestPatch
+        REQUEST_TRACE_NAME = 'rest_client.request'.freeze
+
+        def self.included(base)
+          if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0.0')
+            base.class_eval do
+              alias_method :execute_without_datadog, :execute
+              remove_method :execute
+              include InstanceMethods
+            end
+          else
+            base.send(:prepend, InstanceMethods)
+          end
+        end
+
+        # Compatibility shim for Rubies not supporting `.prepend`
+        module InstanceMethodsCompatibility
+          def execute(&block)
+            execute_without_datadog(&block)
+          end
+        end
+
+        # InstanceMethods - implementing instrumentation
+        module InstanceMethods
+          include InstanceMethodsCompatibility unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0.0')
+
+          def execute(&block)
+            uri = URI.parse(url)
+
+            return super(&block) unless datadog_configuration[:tracer].enabled
+
+            datadog_trace_request(uri) do |span|
+              if datadog_configuration[:distributed_tracing]
+                Datadog::HTTPPropagator.inject!(span.context, processed_headers)
+              end
+
+              super(&block)
+            end
+          end
+
+          def datadog_tag_request(uri, span)
+            span.resource = method.to_s.upcase
+            span.set_tag(Ext::HTTP::URL, uri.path)
+            span.set_tag(Ext::HTTP::METHOD, method.to_s.upcase)
+            span.set_tag(Ext::NET::TARGET_HOST, uri.host)
+            span.set_tag(Ext::NET::TARGET_PORT, uri.port)
+          end
+
+          def datadog_trace_request(uri)
+            span = datadog_configuration[:tracer].trace(REQUEST_TRACE_NAME,
+                                                        service: datadog_configuration[:service_name],
+                                                        span_type: Datadog::Ext::AppTypes::WEB)
+
+            datadog_tag_request(uri, span)
+
+            response = yield(span)
+
+            span.set_tag(Ext::HTTP::STATUS_CODE, response.code)
+            response
+          rescue ::RestClient::ExceptionWithResponse => e
+            span.set_error(e) if Ext::HTTP::ERROR_RANGE.cover?(e.http_code)
+            span.set_tag(Ext::HTTP::STATUS_CODE, e.http_code)
+
+            raise e
+            # rubocop:disable Lint/RescueException
+          rescue Exception => e
+            # rubocop:enable Lint/RescueException
+            span.set_error(e)
+
+            raise e
+          ensure
+            span.finish
+          end
+
+          def datadog_configuration
+            Datadog.configuration[:rest_client]
+          end
+        end
+      end
+    end
+  end
+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/monkey.rb

@@ -15,8 +15,6 @@ module Datadog
 
     module_function
 
-    attr_writer :registry
-
     def registry
       log_deprecation_warning('Monkey#registry')
       @registry
@@ -54,11 +52,6 @@ module Datadog
     end
 
     class << self
-      def registry
-        log_deprecation_warning('Monkey#registry')
-        @registry
-      end
-
       attr_writer :registry
     end
   end

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.

data/lib/ddtrace/pin.rb

@@ -10,7 +10,7 @@ module Datadog
       obj.datadog_pin
     end
 
-    attr_accessor :service_name
+    attr_reader :service_name
     attr_accessor :app
     attr_accessor :tags
     attr_accessor :app_type

data/lib/ddtrace/propagation/http_propagator.rb

@@ -9,6 +9,12 @@ module Datadog
 
     # inject! popolates the env with span ID, trace ID and sampling priority
     def self.inject!(context, env)
+      # Prevent propagation from being attempted if context provided is nil.
+      if context.nil?
+        Datadog::Tracer.log.debug('Cannot inject context into env to propagate over HTTP: context is nil.'.freeze)
+        return
+      end
+
       env[HTTP_HEADER_TRACE_ID] = context.trace_id.to_s
       env[HTTP_HEADER_PARENT_ID] = context.span_id.to_s
       env[HTTP_HEADER_SAMPLING_PRIORITY] = context.sampling_priority.to_s

data/lib/ddtrace/span.rb

@@ -25,7 +25,6 @@ module Datadog
                   :tracer, :context
 
     attr_reader :parent
-
     # Create a new span linked to the given tracer. Call the \Tracer method <tt>start_span()</tt>
     # and then <tt>finish()</tt> once the tracer operation is over.
     #

data/lib/ddtrace/tracer.rb

@@ -24,6 +24,7 @@ module Datadog
     attr_writer :default_service
 
     ALLOWED_SPAN_OPTIONS = [:service, :resource, :span_type].freeze
+    DEFAULT_ON_ERROR = proc { |span, error| span.set_error(error) unless span.nil? }
 
     # Global, memoized, lazy initialized instance of a logger that is used within the the Datadog
     # namespace. This logger outputs to +STDOUT+ by default, and is considered thread-safe.
@@ -277,14 +278,23 @@ module Datadog
     # * +tags+: extra tags which should be added to the span.
     def trace(name, options = {})
       options[:child_of] = call_context
-      span = start_span(name, options)
 
       # call the finish only if a block is given; this ensures
       # that a call to tracer.trace() without a block, returns
       # a span that should be manually finished.
       if block_given?
+        span = nil
+        return_value = nil
+
         begin
-          yield(span)
+          begin
+            span = start_span(name, options)
+          # rubocop:disable Lint/UselessAssignment
+          rescue StandardError => e
+            Datadog::Tracer.log.debug('Failed to start span: #{e}')
+          ensure
+            return_value = yield(span)
+          end
         # rubocop:disable Lint/RescueException
         # Here we really want to catch *any* exception, not only StandardError,
         # as we really have no clue of what is in the block,
@@ -292,13 +302,15 @@ module Datadog
         # It's not a problem since we re-raise it afterwards so for example a
         # SignalException::Interrupt would still bubble up.
         rescue Exception => e
-          span.set_error(e)
+          (options[:on_error] || DEFAULT_ON_ERROR).call(span, e)
           raise e
         ensure
-          span.finish()
+          span.finish unless span.nil?
         end
+
+        return_value
       else
-        span
+        start_span(name, options)
       end
     end
 
@@ -334,6 +346,11 @@ module Datadog
       call_context.current_span
     end
 
+    # Return the current active root span or +nil+.
+    def active_root_span
+      call_context.current_root_span
+    end
+
     # Send the trace to the writer to enqueue the spans list in the agent
     # sending queue.
     def write(trace)