ddtrace 0.12.1 → 0.13.0.beta1

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

@@ -17,6 +17,7 @@ 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
@@ -24,16 +25,14 @@ 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 payload[:action] == 'GET'.freeze &&
-                    current_span.try(:name) == 'rails.cache'.freeze &&
-                    current_span.try(:resource) == 'GET'.freeze
-
-          tracing_context = payload.fetch(:tracing_context)
+          return if current_span.try('name') == 'rails.cache' &&
+                    current_span.try('resource') == 'GET' &&
+                    payload[:action] == 'GET'
 
           # 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'.freeze, service: service, span_type: type)
+          span = tracer.trace('rails.cache', service: service, span_type: type)
           span.resource = payload.fetch(:action)
           tracing_context[:dd_cache_span] = span
         rescue StandardError => e
@@ -49,12 +48,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'.freeze, store)
+            span.set_tag('rails.cache.backend', store)
             cache_key = Datadog::Utils.truncate(payload.fetch(:key), Ext::CACHE::MAX_KEY_SIZE)
-            span.set_tag('rails.cache.key'.freeze, cache_key)
+            span.set_tag('rails.cache.key', 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,11 +6,6 @@ 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
@@ -29,22 +24,25 @@ 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)
-            # 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
+            # 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)
             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)
@@ -62,19 +60,8 @@ module Datadog
                        else
                          layout_name.try(:[], 'virtual_path')
                        end
-              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
+              @tracing_context[:template_name] = template_name
+              @tracing_context[:layout] = layout
             rescue StandardError => e
               Datadog::Tracer.log.debug(e.message)
             end
@@ -83,21 +70,6 @@ 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
@@ -118,23 +90,30 @@ module Datadog
       do_once(:patch_partial_renderer) do
         klass.class_eval do
           def render_with_datadog(*args, &block)
-            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
+            # 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)
           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'))
-              if template_name
-                active_datadog_span.set_tag(
-                  Datadog::RailsRendererPatcher::TAG_TEMPLATE_NAME,
-                  template_name
-                )
-              end
+              tracing_contexts[current_span_id][:template_name] = template_name
             rescue StandardError => e
               Datadog::Tracer.log.debug(e.message)
             end
@@ -143,19 +122,15 @@ module Datadog
             render_partial_without_datadog(*args)
           end
 
-          private
-
-          attr_accessor :active_datadog_span
-
-          def datadog_tracer
-            Datadog.configuration[:rails][:tracer]
+          # 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 ||= {}
           end
 
-          def with_datadog_span(span)
-            self.active_datadog_span = span
-            yield
-          ensure
-            self.active_datadog_span = nil
+          def current_span_id
+            Datadog.configuration[:rails][:tracer].call_context.current_span.span_id
           end
 
           # method aliasing to patch the class
@@ -182,9 +157,79 @@ module Datadog
 
     def patch_process_action
       do_once(:patch_process_action) do
-        require 'ddtrace/contrib/rails/action_controller_patch'
+        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
 
-        ::ActionController::Metal.send(:include, Datadog::Contrib::Rails::ActionControllerPatch)
+            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)
       end
     end
   end
@@ -225,7 +270,6 @@ 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',
@@ -253,7 +297,6 @@ 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',
@@ -281,7 +324,6 @@ 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',
@@ -309,7 +351,6 @@ 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