ddtrace 0.8.2 → 0.9.0

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

@@ -1,50 +1,170 @@
 module Datadog
   # RailsRendererPatcher contains function to patch Rails rendering libraries.
+  # rubocop:disable Lint/RescueException
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/BlockLength
   module RailsRendererPatcher
     module_function
 
     def patch_renderer
-      patch_renderer_render_template
-      patch_renderer_render_partial
+      if defined?(::ActionView::TemplateRenderer) && defined?(::ActionView::PartialRenderer)
+        patch_template_renderer(::ActionView::TemplateRenderer)
+        patch_partial_renderer(::ActionView::PartialRenderer)
+      elsif defined?(::ActionView::Rendering) && defined?(::ActionView::Partials::PartialRenderer)
+        # NOTE: Rails < 3.1 compatibility: different classes are used
+        patch_template_renderer(::ActionView::Rendering)
+        patch_partial_renderer(::ActionView::Partials::PartialRenderer)
+      else
+        Datadog::Tracer.log.debug('Expected Template/Partial classes not found; template rendering disabled')
+      end
     end
 
-    def patch_renderer_render_template
-      if defined?(::ActionView::Renderer)
-        ::ActionView::Renderer.class_eval do
-          alias_method :render_template_without_datadog, :render_template
-          def render_template(*args, &block)
-            ActiveSupport::Notifications.instrument('start_render_template.action_view')
-            render_template_without_datadog(*args, &block)
+    def patch_template_renderer(klass)
+      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?
+            ::ActiveSupport::Notifications.instrument(
+              '!datadog.start_render_template.action_view',
+              tracing_context: @tracing_context
+            )
           end
+          render_without_datadog(*args)
+        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
+          ::ActiveSupport::Notifications.instrument(
+            '!datadog.finish_render_template.action_view',
+            tracing_context: @tracing_context
+          )
         end
-      else # Rails < 3.1
-        ::ActionView::Template.class_eval do
-          alias_method :render_template_without_datadog, :render
-          def render(*args, &block)
-            ActiveSupport::Notifications.instrument('start_render_template.action_view')
-            render_template_without_datadog(*args, &block)
+
+        def render_template_with_datadog(*args)
+          begin
+            # arguments based on render_template signature (stable since Rails 3.2)
+            template = args[0]
+            layout_name = args[1]
+
+            # update the tracing context with computed values before the rendering
+            template_name = template.try('identifier')
+            template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(template_name)
+            layout = if layout_name.is_a?(String)
+                       # NOTE: Rails < 3.1 compatibility: the second argument is the layout name
+                       layout_name
+                     else
+                       layout_name.try(:[], 'virtual_path')
+                     end
+            @tracing_context[:template_name] = template_name
+            @tracing_context[:layout] = layout
+          rescue StandardError => e
+            Datadog::Tracer.log.debug(e.message)
           end
+
+          # execute the original function anyway
+          render_template_without_datadog(*args)
+        end
+
+        # method aliasing to patch the class
+        alias_method :render_without_datadog, :render
+        alias_method :render, :render_with_datadog
+
+        if klass.private_method_defined?(:render_template) || klass.method_defined?(:render_template)
+          alias_method :render_template_without_datadog, :render_template
+          alias_method :render_template, :render_template_with_datadog
+        else
+          # NOTE: Rails < 3.1 compatibility: the method name is different
+          alias_method :render_template_without_datadog, :_render_template
+          alias_method :_render_template, :render_template_with_datadog
         end
       end
     end
 
-    def patch_renderer_render_partial
-      if defined?(::ActionView::PartialRenderer)
-        ::ActionView::PartialRenderer.class_eval do
-          alias_method :render_partial_without_datadog, :render_partial
-          def render_partial(*args, &block)
-            ActiveSupport::Notifications.instrument('start_render_partial.action_view')
-            render_partial_without_datadog(*args, &block)
+    def patch_partial_renderer(klass)
+      klass.class_eval do
+        def render_with_datadog(*args, &block)
+          # create a tracing context and start the rendering span
+          @tracing_context = {}
+          ::ActiveSupport::Notifications.instrument(
+            '!datadog.start_render_partial.action_view',
+            tracing_context: @tracing_context
+          )
+          render_without_datadog(*args)
+        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
+          ::ActiveSupport::Notifications.instrument(
+            '!datadog.finish_render_partial.action_view',
+            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'))
+            @tracing_context[:template_name] = template_name
+          rescue StandardError => e
+            Datadog::Tracer.log.debug(e.message)
           end
+
+          # execute the original function anyway
+          render_partial_without_datadog(*args)
         end
-      else # Rails < 3.1
-        ::ActionView::Partials::PartialRenderer.class_eval do
-          alias_method :render_partial_without_datadog, :render
-          def render(*args, &block)
-            ActiveSupport::Notifications.instrument('start_render_partial.action_view')
-            render_partial_without_datadog(*args, &block)
+
+        # method aliasing to patch the class
+        alias_method :render_without_datadog, :render
+        alias_method :render, :render_with_datadog
+        alias_method :render_partial_without_datadog, :render_partial
+        alias_method :render_partial, :render_partial_with_datadog
+      end
+    end
+  end
+
+  # RailsActionPatcher contains functions to patch Rails action controller instrumentation
+  module RailsActionPatcher
+    module_function
+
+    def patch_action_controller
+      patch_process_action
+    end
+
+    def patch_process_action
+      ::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
+          raw_payload = {
+            controller: self.class.name,
+            action: action_name,
+            tracing_context: {}
+          }
+
+          # emits two different signals that start and finish the trace; this approach
+          # mimics the original behavior that is available since Rails 3.0:
+          # - https://github.com/rails/rails/blob/3-0-stable/actionpack/lib/action_controller/metal/instrumentation.rb#L17-L35
+          # - https://github.com/rails/rails/blob/5-1-stable/actionpack/lib/action_controller/metal/instrumentation.rb#L17-L39
+          ActiveSupport::Notifications.instrument('!datadog.start_processing.action_controller', raw_payload)
+
+          # process the request and finish the trace
+          ActiveSupport::Notifications.instrument('!datadog.finish_processing.action_controller', raw_payload) do |payload|
+            result = process_action_without_datadog(*args)
+            payload[:status] = response.status
+            result
           end
         end
+
+        alias_method :process_action_without_datadog, :process_action
+        alias_method :process_action, :process_action_with_datadog
       end
     end
   end
@@ -58,7 +178,6 @@ module Datadog
       patch_cache_store_fetch
       patch_cache_store_write
       patch_cache_store_delete
-      patch_cache_store_instrument
     end
 
     def cache_store_class(k)
@@ -81,8 +200,17 @@ module Datadog
       cache_store_class(:read).class_eval do
         alias_method :read_without_datadog, :read
         def read(*args, &block)
-          ActiveSupport::Notifications.instrument('start_cache_read.active_support')
-          read_without_datadog(*args, &block)
+          raw_payload = {
+            action: 'GET',
+            key: args[0],
+            tracing_context: {}
+          }
+
+          ActiveSupport::Notifications.instrument('!datadog.start_cache_tracing.active_support', raw_payload)
+
+          ActiveSupport::Notifications.instrument('!datadog.finish_cache_tracing.active_support', raw_payload) do
+            read_without_datadog(*args, &block)
+          end
         end
       end
     end
@@ -91,8 +219,17 @@ module Datadog
       cache_store_class(:fetch).class_eval do
         alias_method :fetch_without_datadog, :fetch
         def fetch(*args, &block)
-          ActiveSupport::Notifications.instrument('start_cache_fetch.active_support')
-          fetch_without_datadog(*args, &block)
+          raw_payload = {
+            action: 'GET',
+            key: args[0],
+            tracing_context: {}
+          }
+
+          ActiveSupport::Notifications.instrument('!datadog.start_cache_tracing.active_support', raw_payload)
+
+          ActiveSupport::Notifications.instrument('!datadog.finish_cache_tracing.active_support', raw_payload) do
+            fetch_without_datadog(*args, &block)
+          end
         end
       end
     end
@@ -101,8 +238,17 @@ module Datadog
       cache_store_class(:write).class_eval do
         alias_method :write_without_datadog, :write
         def write(*args, &block)
-          ActiveSupport::Notifications.instrument('start_cache_write.active_support')
-          write_without_datadog(*args, &block)
+          raw_payload = {
+            action: 'SET',
+            key: args[0],
+            tracing_context: {}
+          }
+
+          ActiveSupport::Notifications.instrument('!datadog.start_cache_tracing.active_support', raw_payload)
+
+          ActiveSupport::Notifications.instrument('!datadog.finish_cache_tracing.active_support', raw_payload) do
+            write_without_datadog(*args, &block)
+          end
         end
       end
     end
@@ -111,25 +257,17 @@ module Datadog
       cache_store_class(:delete).class_eval do
         alias_method :delete_without_datadog, :delete
         def delete(*args, &block)
-          ActiveSupport::Notifications.instrument('start_cache_delete.active_support')
-          delete_without_datadog(*args, &block)
-        end
-      end
-    end
+          raw_payload = {
+            action: 'DELETE',
+            key: args[0],
+            tracing_context: {}
+          }
 
-    def patch_cache_store_instrument
-      # by default, Rails 3 doesn't instrument the cache system so we should turn it on
-      # using the ActiveSupport::Cache::Store.instrument= function. Unfortunately, early
-      # versions of Rails use a Thread.current store that is not compatible with some
-      # application servers like Passenger.
-      # More details: https://github.com/rails/rails/blob/v3.2.22.5/activesupport/lib/active_support/cache.rb#L175-L177
-      return unless ::Rails::VERSION::MAJOR.to_i == 3
-      ::ActiveSupport::Cache::Store.singleton_class.class_eval do
-        # Add the instrument function that Rails 3.x uses
-        # to know if the underlying cache should be instrumented or not. By default,
-        # we force that instrumentation if the Rails application is auto instrumented.
-        def instrument
-          true
+          ActiveSupport::Notifications.instrument('!datadog.start_cache_tracing.active_support', raw_payload)
+
+          ActiveSupport::Notifications.instrument('!datadog.finish_cache_tracing.active_support', raw_payload) do
+            delete_without_datadog(*args, &block)
+          end
         end
       end
     end

data/lib/ddtrace/contrib/redis/quantize.rb

@@ -11,18 +11,16 @@ module Datadog
         module_function
 
         def format_arg(arg)
-          a = arg.to_s
-          a = a[0..(VALUE_MAX_LEN - TOO_LONG_MARK.length - 1)] + TOO_LONG_MARK if a.length > VALUE_MAX_LEN
-          a
+          str = arg.to_s
+          Utils.truncate(str, VALUE_MAX_LEN, TOO_LONG_MARK)
         rescue StandardError => e
-          Datadog::Tracer.log.debug("non formattable Redis arg #{a}: #{e}")
+          Datadog::Tracer.log.debug("non formattable Redis arg #{str}: #{e}")
           PLACEHOLDER
         end
 
         def format_command_args(command_args)
           cmd = command_args.map { |x| format_arg(x) }.join(' ')
-          cmd = cmd[0..(CMD_MAX_LEN - TOO_LONG_MARK.length - 1)] + TOO_LONG_MARK if cmd.length > CMD_MAX_LEN
-          cmd
+          Utils.truncate(cmd, CMD_MAX_LEN, TOO_LONG_MARK)
         end
       end
     end

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

@@ -0,0 +1,38 @@
+module Datadog
+  module Contrib
+    module Resque
+      SERVICE = 'resque'.freeze
+
+      # Patcher for Resque integration - sets up the pin for the integration
+      module Patcher
+        @patched = false
+
+        class << self
+          def patch
+            return @patched if patched? || !defined?(::Resque)
+
+            require 'ddtrace/ext/app_types'
+
+            add_pin
+            @patched = true
+          rescue => e
+            Tracer.log.error("Unable to apply Resque integration: #{e}")
+            @patched
+          end
+
+          def patched?
+            @patched
+          end
+
+          private
+
+          def add_pin
+            Pin.new(SERVICE, app_type: Ext::AppTypes::WORKER).tap do |pin|
+              pin.onto(::Resque)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'ddtrace/ext/app_types'
+require 'resque'
+
+module Datadog
+  module Contrib
+    module Resque
+      # Uses Resque job hooks to create traces
+      module ResqueJob
+        def around_perform(*args)
+          pin = Pin.get_from(::Resque)
+          pin.tracer.trace('resque.job', service: pin.service) do |span|
+            span.resource = name
+            span.span_type = pin.app_type
+            yield
+            span.service = pin.service
+          end
+        end
+
+        def after_perform(*args)
+          pin = Pin.get_from(::Resque)
+          pin.tracer.shutdown!
+        end
+      end
+    end
+  end
+end
+
+Resque.before_first_fork do
+  pin = Datadog::Pin.get_from(Resque)
+  pin.tracer.set_service_info(pin.service, 'resque', Datadog::Ext::AppTypes::WORKER)
+end

data/lib/ddtrace/contrib/sucker_punch/exception_handler.rb

@@ -0,0 +1,26 @@
+require 'sucker_punch'
+
+module Datadog
+  module Contrib
+    module SuckerPunch
+      # Patches `sucker_punch` exception handling
+      module ExceptionHandler
+        METHOD = ->(e, *) { raise(e) }
+
+        module_function
+
+        def patch!
+          ::SuckerPunch.class_eval do
+            class << self
+              alias_method :__exception_handler, :exception_handler
+
+              def exception_handler
+                ::Datadog::Contrib::SuckerPunch::ExceptionHandler::METHOD
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'sucker_punch'
+
+module Datadog
+  module Contrib
+    module SuckerPunch
+      # Defines instrumentation patches for the `sucker_punch` gem
+      module Instrumentation
+        module_function
+
+        # rubocop:disable Metrics/MethodLength
+        def patch!
+          ::SuckerPunch::Job::ClassMethods.class_eval do
+            alias_method :__run_perform_without_datadog, :__run_perform
+            def __run_perform(*args)
+              pin = Datadog::Pin.get_from(::SuckerPunch)
+              pin.tracer.provider.context = Datadog::Context.new
+
+              __with_instrumentation('sucker_punch.perform') do |span|
+                span.resource = "PROCESS #{self}"
+                __run_perform_without_datadog(*args)
+              end
+            rescue => e
+              ::SuckerPunch.__exception_handler.call(e, self, args)
+            end
+
+            alias_method :__perform_async, :perform_async
+            def perform_async(*args)
+              __with_instrumentation('sucker_punch.perform_async') do |span|
+                span.resource = "ENQUEUE #{self}"
+                __perform_async(*args)
+              end
+            end
+
+            alias_method :__perform_in, :perform_in
+            def perform_in(interval, *args)
+              __with_instrumentation('sucker_punch.perform_in') do |span|
+                span.resource = "ENQUEUE #{self}"
+                span.set_tag('sucker_punch.perform_in', interval)
+                __perform_in(interval, *args)
+              end
+            end
+
+            private
+
+            def __with_instrumentation(name)
+              pin = Datadog::Pin.get_from(::SuckerPunch)
+
+              pin.tracer.trace(name) do |span|
+                span.service = pin.service
+                span.span_type = pin.app_type
+                span.set_tag('sucker_punch.queue', to_s)
+                yield span
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end