ddtrace 0.12.0 → 0.13.0

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

@@ -0,0 +1,77 @@
+module Datadog
+  module Contrib
+    module Rails
+      # Instrument ActiveController processing
+      module ActionControllerPatch
+        def self.included(base)
+          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0.0')
+            base.send(:prepend, ProcessActionPatch)
+          else
+            base.class_eval do
+              alias_method :process_action_without_datadog, :process_action
+
+              include ProcessActionPatch
+            end
+          end
+        end
+
+        # Compatibility module for Ruby versions not supporting #prepend
+        module ProcessActionCompatibilityPatch
+          def process_action(*args)
+            process_action_without_datadog(*args)
+          end
+        end
+
+        # ActionController patch
+        module ProcessActionPatch
+          # compatibility module for Ruby versions not supporting #prepend
+          include ProcessActionCompatibilityPatch unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0.0')
+
+          def process_action(*args)
+            # mutable payload with a tracing context that is used in two different
+            # signals; it propagates the request span so that it can be finished
+            # no matter what
+            payload = {
+              controller: self.class,
+              action: action_name,
+              headers: {
+                # The exception this controller was given in the request,
+                # which is typical if the controller is configured to handle exceptions.
+                request_exception: request.headers['action_dispatch.exception']
+              },
+              tracing_context: {}
+            }
+
+            begin
+              # process and catch request exceptions
+              Datadog::Contrib::Rails::ActionController.start_processing(payload)
+              result = super(*args)
+              status = datadog_response_status
+              payload[:status] = status unless status.nil?
+              result
+            # rubocop:disable Lint/RescueException
+            rescue Exception => e
+              payload[:exception] = [e.class.name, e.message]
+              payload[:exception_object] = e
+              raise e
+            end
+          # rubocop:enable Lint/RescueException
+          ensure
+            Datadog::Contrib::Rails::ActionController.finish_processing(payload)
+          end
+
+          def datadog_response_status
+            case response
+            when ActionDispatch::Response
+              response.status
+            when Array
+              # Likely a Rack response array: first element is the status.
+              status = response.first
+              status.class <= Integer ? status : nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,71 +13,6 @@ module Datadog
             Datadog::RailsRendererPatcher.patch_renderer
           end
         end
-
-        def self.start_render_template(payload)
-          # retrieve the tracing context
-          tracing_context = payload.fetch(:tracing_context)
-
-          # create a new Span and add it to the tracing context
-          tracer = Datadog.configuration[:rails][:tracer]
-          span = tracer.trace('rails.render_template', span_type: Datadog::Ext::HTTP::TEMPLATE)
-          tracing_context[:dd_rails_template_span] = span
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
-
-        def self.finish_render_template(payload)
-          # retrieve the tracing context and the latest active span
-          tracing_context = payload.fetch(:tracing_context)
-          span = tracing_context[:dd_rails_template_span]
-          return if !span || span.finished?
-
-          # finish the tracing and update the execution time
-          begin
-            template_name = tracing_context[:template_name]
-            layout = tracing_context[:layout]
-            exception = tracing_context[:exception]
-
-            span.set_tag('rails.template_name', template_name) if template_name
-            span.set_tag('rails.layout', layout) if layout
-            span.set_error(exception) if exception
-          ensure
-            span.finish()
-          end
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
-
-        def self.start_render_partial(payload)
-          # retrieve the tracing context
-          tracing_context = payload.fetch(:tracing_context)
-
-          tracer = Datadog.configuration[:rails][:tracer]
-          span = tracer.trace('rails.render_partial', span_type: Datadog::Ext::HTTP::TEMPLATE)
-          tracing_context[:dd_rails_partial_span] = span
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
-
-        def self.finish_render_partial(payload)
-          # retrieve the tracing context and the latest active span
-          tracing_context = payload.fetch(:tracing_context)
-          span = tracing_context[:dd_rails_partial_span]
-          return if !span || span.finished?
-
-          # finish the tracing and update the execution time
-          begin
-            template_name = tracing_context[:template_name]
-            exception = tracing_context[:exception]
-
-            span.set_tag('rails.template_name', template_name) if template_name
-            span.set_error(exception) if exception
-          ensure
-            span.finish()
-          end
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
       end
     end
   end

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

@@ -17,7 +17,6 @@ module Datadog
 
         def self.start_trace_cache(payload)
           tracer = Datadog.configuration[:rails][:tracer]
-          tracing_context = payload.fetch(:tracing_context)
 
           # In most of the cases Rails ``fetch()`` and ``read()`` calls are nested.
           # This check ensures that two reads are not nested since they don't provide
@@ -25,14 +24,16 @@ module Datadog
           # NOTE: the ``finish_trace_cache()`` is fired but it already has a safe-guard
           # to avoid any kind of issue.
           current_span = tracer.active_span
-          return if current_span.try('name') == 'rails.cache' &&
-                    current_span.try('resource') == 'GET' &&
-                    payload[:action] == 'GET'
+          return if payload[:action] == 'GET'.freeze &&
+                    current_span.try(:name) == 'rails.cache'.freeze &&
+                    current_span.try(:resource) == 'GET'.freeze
+
+          tracing_context = payload.fetch(:tracing_context)
 
           # create a new ``Span`` and add it to the tracing context
           service = Datadog.configuration[:rails][:cache_service]
           type = Datadog::Ext::CACHE::TYPE
-          span = tracer.trace('rails.cache', service: service, span_type: type)
+          span = tracer.trace('rails.cache'.freeze, service: service, span_type: type)
           span.resource = payload.fetch(:action)
           tracing_context[:dd_cache_span] = span
         rescue StandardError => e
@@ -48,12 +49,12 @@ module Datadog
           begin
             # discard parameters from the cache_store configuration
             store, = *Array.wrap(::Rails.configuration.cache_store).flatten
-            span.set_tag('rails.cache.backend', store)
+            span.set_tag('rails.cache.backend'.freeze, store)
             cache_key = Datadog::Utils.truncate(payload.fetch(:key), Ext::CACHE::MAX_KEY_SIZE)
-            span.set_tag('rails.cache.key', cache_key)
+            span.set_tag('rails.cache.key'.freeze, cache_key)
             span.set_error(payload[:exception]) if payload[:exception]
           ensure
-            span.finish()
+            span.finish
           end
         rescue StandardError => e
           Datadog::Tracer.log.debug(e.message)

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

@@ -6,6 +6,11 @@ module Datadog
   module RailsRendererPatcher
     include Datadog::Patcher
 
+    SPAN_NAME_RENDER_PARTIAL = 'rails.render_partial'.freeze
+    SPAN_NAME_RENDER_TEMPLATE = 'rails.render_template'.freeze
+    TAG_LAYOUT = 'rails.layout'.freeze
+    TAG_TEMPLATE_NAME = 'rails.template_name'.freeze
+
     module_function
 
     def patch_renderer
@@ -24,25 +29,22 @@ module Datadog
     end
 
     def patch_template_renderer(klass)
+      # rubocop:disable Metrics/BlockLength
       do_once(:patch_template_renderer) do
         klass.class_eval do
           def render_with_datadog(*args, &block)
-            # create a tracing context and start the rendering span
-            # NOTE: Rails < 3.1 compatibility: preserve the tracing
-            # context when a partial is rendered
-            @tracing_context ||= {}
-            if @tracing_context.empty?
-              Datadog::Contrib::Rails::ActionView.start_render_template(tracing_context: @tracing_context)
+            # NOTE: This check exists purely for Rails 3.0 compatibility.
+            #       The 'if' part can be removed when support for Rails 3.0 is removed.
+            if active_datadog_span
+              render_without_datadog(*args, &block)
+            else
+              datadog_tracer.trace(
+                Datadog::RailsRendererPatcher::SPAN_NAME_RENDER_TEMPLATE,
+                span_type: Datadog::Ext::HTTP::TEMPLATE
+              ) do |span|
+                with_datadog_span(span) { render_without_datadog(*args, &block) }
+              end
             end
-
-            render_without_datadog(*args, &block)
-          rescue Exception => e
-            # attach the exception to the tracing context if any
-            @tracing_context[:exception] = e
-            raise e
-          ensure
-            # ensure that the template `Span` is finished even during exceptions
-            Datadog::Contrib::Rails::ActionView.finish_render_template(tracing_context: @tracing_context)
           end
 
           def render_template_with_datadog(*args)
@@ -60,8 +62,19 @@ module Datadog
                        else
                          layout_name.try(:[], 'virtual_path')
                        end
-              @tracing_context[:template_name] = template_name
-              @tracing_context[:layout] = layout
+              if template_name
+                active_datadog_span.set_tag(
+                  Datadog::RailsRendererPatcher::TAG_TEMPLATE_NAME,
+                  template_name
+                )
+              end
+
+              if layout
+                active_datadog_span.set_tag(
+                  Datadog::RailsRendererPatcher::TAG_LAYOUT,
+                  layout
+                )
+              end
             rescue StandardError => e
               Datadog::Tracer.log.debug(e.message)
             end
@@ -70,6 +83,21 @@ module Datadog
             render_template_without_datadog(*args)
           end
 
+          private
+
+          attr_accessor :active_datadog_span
+
+          def datadog_tracer
+            Datadog.configuration[:rails][:tracer]
+          end
+
+          def with_datadog_span(span)
+            self.active_datadog_span = span
+            yield
+          ensure
+            self.active_datadog_span = nil
+          end
+
           # method aliasing to patch the class
           alias_method :render_without_datadog, :render
           alias_method :render, :render_with_datadog
@@ -90,30 +118,23 @@ module Datadog
       do_once(:patch_partial_renderer) do
         klass.class_eval do
           def render_with_datadog(*args, &block)
-            # Create a tracing context and start the rendering span
-            tracing_context = {}
-            Datadog::Contrib::Rails::ActionView.start_render_partial(tracing_context: tracing_context)
-            tracing_contexts[current_span_id] = tracing_context
-
-            render_without_datadog(*args)
-          rescue Exception => e
-            # attach the exception to the tracing context if any
-            tracing_contexts[current_span_id][:exception] = e
-            raise e
-          ensure
-            # Ensure that the template `Span` is finished even during exceptions
-            # Remove the existing tracing context (to avoid leaks)
-            tracing_contexts.delete(current_span_id)
-
-            # Then finish the span associated with the context
-            Datadog::Contrib::Rails::ActionView.finish_render_partial(tracing_context: tracing_context)
+            datadog_tracer.trace(
+              Datadog::RailsRendererPatcher::SPAN_NAME_RENDER_PARTIAL,
+              span_type: Datadog::Ext::HTTP::TEMPLATE
+            ) do |span|
+              with_datadog_span(span) { render_without_datadog(*args) }
+            end
           end
 
           def render_partial_with_datadog(*args)
             begin
-              # update the tracing context with computed values before the rendering
               template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(@template.try('identifier'))
-              tracing_contexts[current_span_id][:template_name] = template_name
+              if template_name
+                active_datadog_span.set_tag(
+                  Datadog::RailsRendererPatcher::TAG_TEMPLATE_NAME,
+                  template_name
+                )
+              end
             rescue StandardError => e
               Datadog::Tracer.log.debug(e.message)
             end
@@ -122,15 +143,19 @@ module Datadog
             render_partial_without_datadog(*args)
           end
 
-          # Table of tracing contexts, one per partial/span, keyed by span_id
-          # because there will be multiple concurrent contexts, depending on how
-          # many partials are nested within one another.
-          def tracing_contexts
-            @tracing_contexts ||= {}
+          private
+
+          attr_accessor :active_datadog_span
+
+          def datadog_tracer
+            Datadog.configuration[:rails][:tracer]
           end
 
-          def current_span_id
-            Datadog.configuration[:rails][:tracer].call_context.current_span.span_id
+          def with_datadog_span(span)
+            self.active_datadog_span = span
+            yield
+          ensure
+            self.active_datadog_span = nil
           end
 
           # method aliasing to patch the class
@@ -157,79 +182,9 @@ module Datadog
 
     def patch_process_action
       do_once(:patch_process_action) do
-        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0.0')
-          # Patch Rails controller base class
-          ::ActionController::Metal.send(:prepend, ActionControllerPatch)
-        else
-          # Rewrite module that gets composed into the Rails controller base class
-          ::ActionController::Instrumentation.class_eval do
-            def process_action_with_datadog(*args)
-              # mutable payload with a tracing context that is used in two different
-              # signals; it propagates the request span so that it can be finished
-              # no matter what
-              payload = {
-                controller: self.class,
-                action: action_name,
-                headers: {
-                  # The exception this controller was given in the request,
-                  # which is typical if the controller is configured to handle exceptions.
-                  request_exception: request.headers['action_dispatch.exception']
-                },
-                tracing_context: {}
-              }
-
-              begin
-                # process and catch request exceptions
-                Datadog::Contrib::Rails::ActionController.start_processing(payload)
-                result = process_action_without_datadog(*args)
-                payload[:status] = response.status
-                result
-              rescue Exception => e
-                payload[:exception] = [e.class.name, e.message]
-                payload[:exception_object] = e
-                raise e
-              end
-            ensure
-              Datadog::Contrib::Rails::ActionController.finish_processing(payload)
-            end
+        require 'ddtrace/contrib/rails/action_controller_patch'
 
-            alias_method :process_action_without_datadog, :process_action
-            alias_method :process_action, :process_action_with_datadog
-          end
-        end
-      end
-    end
-
-    # ActionController patch for Ruby 2.0+
-    module ActionControllerPatch
-      def process_action(*args)
-        # mutable payload with a tracing context that is used in two different
-        # signals; it propagates the request span so that it can be finished
-        # no matter what
-        payload = {
-          controller: self.class,
-          action: action_name,
-          headers: {
-            # The exception this controller was given in the request,
-            # which is typical if the controller is configured to handle exceptions.
-            request_exception: request.headers['action_dispatch.exception']
-          },
-          tracing_context: {}
-        }
-
-        begin
-          # process and catch request exceptions
-          Datadog::Contrib::Rails::ActionController.start_processing(payload)
-          result = super(*args)
-          payload[:status] = response.status
-          result
-        rescue Exception => e
-          payload[:exception] = [e.class.name, e.message]
-          payload[:exception_object] = e
-          raise e
-        end
-      ensure
-        Datadog::Contrib::Rails::ActionController.finish_processing(payload)
+        ::ActionController::Metal.send(:include, Datadog::Contrib::Rails::ActionControllerPatch)
       end
     end
   end
@@ -270,6 +225,7 @@ module Datadog
       do_once(:patch_cache_store_read) do
         cache_store_class(:read).class_eval do
           alias_method :read_without_datadog, :read
+
           def read(*args, &block)
             payload = {
               action: 'GET',
@@ -297,6 +253,7 @@ module Datadog
       do_once(:patch_cache_store_fetch) do
         cache_store_class(:fetch).class_eval do
           alias_method :fetch_without_datadog, :fetch
+
           def fetch(*args, &block)
             payload = {
               action: 'GET',
@@ -324,6 +281,7 @@ module Datadog
       do_once(:patch_cache_store_write) do
         cache_store_class(:write).class_eval do
           alias_method :write_without_datadog, :write
+
           def write(*args, &block)
             payload = {
               action: 'SET',
@@ -351,6 +309,7 @@ module Datadog
       do_once(:patch_cache_store_delete) do
         cache_store_class(:delete).class_eval do
           alias_method :delete_without_datadog, :delete
+
           def delete(*args, &block)
             payload = {
               action: 'DELETE',

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

@@ -0,0 +1,70 @@
+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
+
+        # Instance methods for Rake instrumentation
+        module InstanceMethods
+          def invoke(*args)
+            return super unless enabled?
+
+            tracer.trace(SPAN_NAME_INVOKE) do |span|
+              super
+              annotate_invoke!(span, args)
+            end
+          end
+
+          def execute(args = nil)
+            return super unless enabled?
+
+            tracer.trace(SPAN_NAME_EXECUTE) do |span|
+              super
+              annotate_execute!(span, args)
+            end
+          end
+
+          private
+
+          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?
+          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?
+          rescue StandardError => e
+            Datadog::Tracer.log.debug("Error while tracing Rake execute: #{e.message}")
+          end
+
+          def quantize_args(args)
+            quantize_options = Datadog.configuration[:rake][:quantize][:args]
+            Datadog::Quantization::Hash.format(args, quantize_options)
+          end
+
+          def enabled?
+            configuration[:enabled] == true
+          end
+
+          def tracer
+            configuration[:tracer]
+          end
+
+          def configuration
+            Datadog.configuration[:rake]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/rake/instrumentation'
+
+module Datadog
+  module Contrib
+    module Rake
+      # Patcher for Rake instrumentation
+      module Patcher
+        include Base
+
+        register_as :rake
+        option :service_name, default: 'rake'
+        option :tracer, default: Datadog.tracer
+        option :enabled, default: true
+        option :quantize, default: {}
+
+        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
+        end
+
+        def patch_rake
+          ::Rake::Task.send(:include, Instrumentation)
+        end
+
+        def compatible?
+          RUBY_VERSION >= '2.0.0' && defined?(::Rake)
+        end
+
+        def configuration
+          Datadog.configuration[:rake]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'ddtrace/ext/sql'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/sequel/utils'
+
+module Datadog
+  module Contrib
+    module Sequel
+      # Adds instrumentation to Sequel::Database
+      module Database
+        def self.included(base)
+          base.send(:prepend, InstanceMethods)
+        end
+
+        # Instance methods for instrumenting Sequel::Database
+        module InstanceMethods
+          def run(sql, options = ::Sequel::OPTS)
+            opts = parse_opts(sql, options)
+
+            response = nil
+
+            datadog_pin.tracer.trace('sequel.query') do |span|
+              span.service = datadog_pin.service
+              span.resource = opts[:query]
+              span.span_type = Datadog::Ext::SQL::TYPE
+              span.set_tag('sequel.db.vendor', adapter_name)
+              response = super(sql, options)
+            end
+            response
+          end
+
+          def datadog_pin
+            @pin ||= Datadog::Pin.new(
+              Datadog.configuration[:sequel][:service_name] || adapter_name,
+              app: Patcher::APP,
+              app_type: Datadog::Ext::AppTypes::DB,
+              tracer: Datadog.configuration[:sequel][:tracer] || Datadog.tracer
+            )
+          end
+
+          private
+
+          def adapter_name
+            Utils.adapter_name(self)
+          end
+
+          def parse_opts(sql, opts)
+            db_opts = if ::Sequel::VERSION < '3.41.0' && self.class.to_s !~ /Dataset$/
+                        @opts
+                      elsif instance_variable_defined?(:@pool) && @pool
+                        @pool.db.opts
+                      end
+            Utils.parse_opts(sql, opts, db_opts)
+          end
+        end
+      end
+    end
+  end
+end