ddtrace 0.26.1 → 0.27.0

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

@@ -0,0 +1,47 @@
+require 'ddtrace/ext/http'
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/action_view/ext'
+require 'ddtrace/contrib/action_view/instrumentation'
+require 'ddtrace/contrib/action_view/utils'
+
+module Datadog
+  module Contrib
+    module ActionView
+      # Patcher enables patching of ActionView module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:action_view)
+        end
+
+        def patch
+          do_once(:action_view) do
+            begin
+              patch_renderer
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Action View integration: #{e} Location: #{e.backtrace.first}")
+            end
+          end
+        end
+
+        def patch_renderer
+          do_once(:patch_renderer) do
+            if defined?(::ActionView::TemplateRenderer) && defined?(::ActionView::PartialRenderer)
+              ::ActionView::TemplateRenderer.send(:prepend, Instrumentation::TemplateRenderer::Rails31Plus)
+              ::ActionView::PartialRenderer.send(:prepend, Instrumentation::PartialRenderer)
+            elsif defined?(::ActionView::Rendering) && defined?(::ActionView::Partials::PartialRenderer)
+              # NOTE: Rails < 3.1 compatibility: different classes are used
+              ::ActionView::Rendering.send(:prepend, Instrumentation::TemplateRenderer::Rails30)
+              ::ActionView::Partials::PartialRenderer.send(:prepend, Instrumentation::PartialRenderer)
+            else
+              Datadog::Tracer.log.debug('Expected Template/Partial classes not found; template rendering disabled')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'ddtrace/contrib/analytics'
+
+module Datadog
+  module Contrib
+    module ActionView
+      # common utilities for Rails
+      module Utils
+        module_function
+
+        # in Rails the template name includes the template full path
+        # and it's better to avoid storing such information. This method
+        # returns the relative path from `views/` or the template name
+        # if a `views/` folder is not in the template full path. A wrong
+        # usage ensures that this method will not crash the tracing system.
+        def normalize_template_name(name)
+          return if name.nil?
+
+          base_path = Datadog.configuration[:action_view][:template_base_path]
+          sections_view = name.split(base_path)
+
+          if sections_view.length == 1
+            name.split('/')[-1]
+          else
+            sections_view[-1]
+          end
+        rescue
+          return name.to_s
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_support/cache/instrumentation.rb

@@ -0,0 +1,157 @@
+require 'ddtrace/contrib/active_support/ext'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      module Cache
+        # Defines instrumentation for ActiveSupport caching
+        # rubocop:disable Lint/RescueException
+        module Instrumentation
+          module_function
+
+          def start_trace_cache(payload)
+            tracer = Datadog.configuration[:active_support][:tracer]
+
+            # 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
+            # interesting details.
+            # 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] == Ext::RESOURCE_CACHE_GET &&
+                      current_span.try(:name) == Ext::SPAN_CACHE &&
+                      current_span.try(:resource) == Ext::RESOURCE_CACHE_GET
+
+            tracing_context = payload.fetch(:tracing_context)
+
+            # create a new ``Span`` and add it to the tracing context
+            service = Datadog.configuration[:active_support][:cache_service]
+            type = Ext::SPAN_TYPE_CACHE
+            span = tracer.trace(Ext::SPAN_CACHE, service: service, span_type: type)
+            span.resource = payload.fetch(:action)
+            tracing_context[:dd_cache_span] = span
+          rescue StandardError => e
+            Datadog::Tracer.log.debug(e.message)
+          end
+
+          def finish_trace_cache(payload)
+            # retrieve the tracing context and continue the trace
+            tracing_context = payload.fetch(:tracing_context)
+            span = tracing_context[:dd_cache_span]
+            return unless span && !span.finished?
+
+            begin
+              # discard parameters from the cache_store configuration
+              if defined?(::Rails)
+                store, = *Array.wrap(::Rails.configuration.cache_store).flatten
+                span.set_tag(Ext::TAG_CACHE_BACKEND, store)
+              end
+
+              normalized_key = ::ActiveSupport::Cache.expand_cache_key(payload.fetch(:key))
+              cache_key = Datadog::Utils.truncate(normalized_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
+              span.set_tag(Ext::TAG_CACHE_KEY, cache_key)
+
+              span.set_error(payload[:exception]) if payload[:exception]
+            ensure
+              span.finish
+            end
+          rescue StandardError => e
+            Datadog::Tracer.log.debug(e.message)
+          end
+
+          # Defines instrumentation for ActiveSupport cache reading
+          module Read
+            def read(*args, &block)
+              payload = {
+                action: Ext::RESOURCE_CACHE_GET,
+                key: args[0],
+                tracing_context: {}
+              }
+
+              begin
+                # process and catch cache exceptions
+                Instrumentation.start_trace_cache(payload)
+                super
+              rescue Exception => e
+                payload[:exception] = [e.class.name, e.message]
+                payload[:exception_object] = e
+                raise e
+              end
+            ensure
+              Instrumentation.finish_trace_cache(payload)
+            end
+          end
+
+          # Defines instrumentation for ActiveSupport cache fetching
+          module Fetch
+            def fetch(*args, &block)
+              payload = {
+                action: Ext::RESOURCE_CACHE_GET,
+                key: args[0],
+                tracing_context: {}
+              }
+
+              begin
+                # process and catch cache exceptions
+                Instrumentation.start_trace_cache(payload)
+                super
+              rescue Exception => e
+                payload[:exception] = [e.class.name, e.message]
+                payload[:exception_object] = e
+                raise e
+              end
+            ensure
+              Instrumentation.finish_trace_cache(payload)
+            end
+          end
+
+          # Defines instrumentation for ActiveSupport cache writing
+          module Write
+            def write(*args, &block)
+              payload = {
+                action: Ext::RESOURCE_CACHE_SET,
+                key: args[0],
+                tracing_context: {}
+              }
+
+              begin
+                # process and catch cache exceptions
+                Instrumentation.start_trace_cache(payload)
+                super
+              rescue Exception => e
+                payload[:exception] = [e.class.name, e.message]
+                payload[:exception_object] = e
+                raise e
+              end
+            ensure
+              Instrumentation.finish_trace_cache(payload)
+            end
+          end
+
+          # Defines instrumentation for ActiveSupport cache deleting
+          module Delete
+            def delete(*args, &block)
+              payload = {
+                action: Ext::RESOURCE_CACHE_DELETE,
+                key: args[0],
+                tracing_context: {}
+              }
+
+              begin
+                # process and catch cache exceptions
+                Instrumentation.start_trace_cache(payload)
+                super
+              rescue Exception => e
+                payload[:exception] = [e.class.name, e.message]
+                payload[:exception_object] = e
+                raise e
+              end
+            ensure
+              Instrumentation.finish_trace_cache(payload)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_support/cache/patcher.rb

@@ -0,0 +1,62 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/active_support/cache/instrumentation'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      module Cache
+        # Patcher enables patching of 'active_support' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def patched?
+            done?(:cache)
+          end
+
+          def patch
+            do_once(:cache) do
+              begin
+                patch_cache_store_read
+                patch_cache_store_fetch
+                patch_cache_store_write
+                patch_cache_store_delete
+              rescue StandardError => e
+                Datadog::Tracer.log.error("Unable to apply Active Support cache integration: #{e}")
+              end
+            end
+          end
+
+          def cache_store_class(meth)
+            ::ActiveSupport::Cache::Store
+          end
+
+          def patch_cache_store_read
+            do_once(:patch_cache_store_read) do
+              cache_store_class(:read).send(:prepend, Cache::Instrumentation::Read)
+            end
+          end
+
+          def patch_cache_store_fetch
+            do_once(:patch_cache_store_fetch) do
+              cache_store_class(:fetch).send(:prepend, Cache::Instrumentation::Fetch)
+            end
+          end
+
+          def patch_cache_store_write
+            do_once(:patch_cache_store_write) do
+              cache_store_class(:write).send(:prepend, Cache::Instrumentation::Write)
+            end
+          end
+
+          def patch_cache_store_delete
+            do_once(:patch_cache_store_delete) do
+              cache_store_class(:delete).send(:prepend, Cache::Instrumentation::Delete)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_support/cache/redis.rb

@@ -0,0 +1,47 @@
+require 'ddtrace/contrib/active_support/cache/patcher'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      module Cache
+        # Support for Redis with ActiveSupport
+        module Redis
+          # Patching behavior for Redis with ActiveSupport
+          module Patcher
+            # For Rails < 5.2 w/ redis-activesupport...
+            # When Redis is used, we can't only patch Cache::Store as it is
+            # Cache::RedisStore, a sub-class of it that is used, in practice.
+            # We need to do a per-method monkey patching as some of them might
+            # be redefined, and some of them not. The latest version of redis-activesupport
+            # redefines write but leaves untouched read and delete:
+            # https://github.com/redis-store/redis-activesupport/blob/master/lib/active_support/cache/redis_store.rb
+            #
+            # For Rails >= 5.2 w/o redis-activesupport...
+            # ActiveSupport includes a Redis cache store internally, and does not require these overrides.
+            # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/cache/redis_cache_store.rb
+            def patch_redis?(meth)
+              !Gem.loaded_specs['redis-activesupport'].nil? \
+                && defined?(::ActiveSupport::Cache::RedisStore) \
+                && ::ActiveSupport::Cache::RedisStore.instance_methods(false).include?(meth)
+            end
+
+            def cache_store_class(meth)
+              if patch_redis?(meth)
+                ::ActiveSupport::Cache::RedisStore
+              else
+                super
+              end
+            end
+          end
+
+          # Decorate Cache patcher with Redis support
+          Cache::Patcher.instance_eval do
+            class << self
+              prepend Redis::Patcher
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/active_support/ext'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      module Configuration
+        # Custom settings for the ActiveSupport integration
+        class Settings < Contrib::Configuration::Settings
+          option  :analytics_enabled,
+                  default: -> { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) },
+                  lazy: true
+
+          option  :analytics_sample_rate,
+                  default: -> { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) },
+                  lazy: true
+
+          option :cache_service, default: Ext::SERVICE_CACHE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Datadog
+  module Contrib
+    module ActiveSupport
+      # ActiveSupport integration constants
+      module Ext
+        APP = 'active_support'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_ACTIVE_SUPPORT_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_ACTIVE_SUPPORT_ANALYTICS_SAMPLE_RATE'.freeze
+        QUANTIZE_CACHE_MAX_KEY_SIZE = 300
+        RESOURCE_CACHE_DELETE = 'DELETE'.freeze
+        RESOURCE_CACHE_GET = 'GET'.freeze
+        RESOURCE_CACHE_SET = 'SET'.freeze
+        SERVICE_CACHE = 'active_support-cache'.freeze
+        SPAN_CACHE = 'rails.cache'.freeze
+        SPAN_TYPE_CACHE = 'cache'.freeze
+        TAG_CACHE_BACKEND = 'rails.cache.backend'.freeze
+        TAG_CACHE_KEY = 'rails.cache.key'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/active_support/configuration/settings'
+require 'ddtrace/contrib/active_support/patcher'
+
+require 'ddtrace/contrib/active_support/cache/redis'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      # Describes the ActiveSupport integration
+      class Integration
+        include Contrib::Integration
+
+        register_as :active_support, auto_patch: false
+
+        def self.version
+          Gem.loaded_specs['activesupport'] && Gem.loaded_specs['activesupport'].version
+        end
+
+        def self.present?
+          super && defined?(::ActiveSupport)
+        end
+
+        def self.compatible?
+          super && version >= Gem::Version.new('3.0')
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          ActiveSupport::Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/active_support/cache/patcher'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      # Patcher enables patching of 'active_support' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:active_support)
+        end
+
+        def patch
+          do_once(:active_support) do
+            begin
+              Cache::Patcher.patch
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Active Support integration: #{e}")
+            end
+          end
+        end
+      end
+    end
+  end
+end