ls-trace 0.1.1

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,25 @@
+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 do |o|
+            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.lazy
+          end
+
+          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/notifications/event.rb

@@ -0,0 +1,62 @@
+require 'ddtrace/contrib/active_support/notifications/subscriber'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      module Notifications
+        # Defines behaviors for an ActiveSupport::Notifications event.
+        # Compose this into a module or class, then define
+        # #event_name, #span_name, and #process. You can then
+        # invoke Event.subscribe! to more easily subscribe to an event.
+        module Event
+          def self.included(base)
+            base.send(:include, Subscriber)
+            base.send(:extend, ClassMethods)
+            base.send(:on_subscribe) { base.subscribe }
+          end
+
+          # Redefines some class behaviors for a Subscriber to make
+          # it a bit simpler for an Event.
+          module ClassMethods
+            def subscribe!
+              super
+            end
+
+            def subscription(span_name = nil, options = nil, tracer = nil)
+              super(
+                span_name || self.span_name,
+                options || span_options,
+                tracer || self.tracer,
+                &method(:process)
+              )
+            end
+
+            def subscribe(pattern = nil, span_name = nil, options = nil, tracer = nil)
+              if supported?
+                super(
+                  pattern || event_name,
+                  span_name || self.span_name,
+                  options || span_options,
+                  tracer || self.tracer,
+                  &method(:process)
+                )
+              end
+            end
+
+            def supported?
+              true
+            end
+
+            def span_options
+              {}
+            end
+
+            def tracer
+              Datadog.tracer
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_support/notifications/subscriber.rb

@@ -0,0 +1,66 @@
+require 'set'
+require 'ddtrace/contrib/active_support/notifications/subscription'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      module Notifications
+        # For classes that listen to ActiveSupport::Notification events.
+        # Creates subscriptions that are wrapped with tracing.
+        module Subscriber
+          def self.included(base)
+            base.send(:extend, ClassMethods)
+          end
+
+          # Class methods that are implemented in the inheriting class.
+          module ClassMethods
+            # Returns a list of subscriptions created for this class.
+            def subscriptions
+              @subscriptions ||= Set.new
+            end
+
+            # Returns whether subscriptions have been activated, via #subscribe!
+            def subscribed?
+              subscribed == true
+            end
+
+            protected
+
+            # Defines a callback for when subscribe! is called.
+            # Should contain subscription setup, defined by the inheriting class.
+            def on_subscribe(&block)
+              @on_subscribe_block = block
+            end
+
+            # Runs the on_subscribe callback once, to activate subscriptions.
+            # Should be triggered by the inheriting class.
+            def subscribe!
+              return subscribed? if subscribed? || on_subscribe_block.nil?
+              on_subscribe_block.call
+              @subscribed = true
+            end
+
+            # Creates a subscription and immediately activates it.
+            def subscribe(pattern, span_name, options = {}, tracer = -> { Datadog.tracer }, &block)
+              subscription(span_name, options, tracer, &block).tap do |subscription|
+                subscription.subscribe(pattern)
+              end
+            end
+
+            # Creates a subscription without activating it.
+            # Subscription is added to the inheriting class' list of subscriptions.
+            def subscription(span_name, options = {}, tracer = -> { Datadog.tracer }, &block)
+              Subscription.new(tracer, span_name, options, &block).tap do |subscription|
+                subscriptions << subscription
+              end
+            end
+
+            private
+
+            attr_reader :subscribed, :on_subscribe_block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_support/notifications/subscription.rb

@@ -0,0 +1,159 @@
+module Datadog
+  module Contrib
+    module ActiveSupport
+      module Notifications
+        # An ActiveSupport::Notification subscription that wraps events with tracing.
+        class Subscription
+          attr_accessor \
+            :span_name,
+            :options
+
+          def initialize(tracer, span_name, options, &block)
+            raise ArgumentError, 'Must be given a block!' unless block_given?
+            @tracer = tracer
+            @span_name = span_name
+            @options = options
+            @handler = Handler.new(&block)
+            @callbacks = Callbacks.new
+          end
+
+          def tracer
+            @tracer.is_a?(Proc) ? @tracer.call : @tracer
+          end
+
+          # ActiveSupport 3.x calls this
+          def call(name, start, finish, id, payload)
+            start_span(name, id, payload, start)
+            finish_span(name, id, payload, finish)
+          end
+
+          # ActiveSupport 4+ calls this on start
+          def start(name, id, payload)
+            start_span(name, id, payload)
+          end
+
+          # ActiveSupport 4+ calls this on finish
+          def finish(name, id, payload)
+            finish_span(name, id, payload)
+          end
+
+          def before_trace(&block)
+            callbacks.add(:before_trace, &block) if block_given?
+          end
+
+          def after_trace(&block)
+            callbacks.add(:after_trace, &block) if block_given?
+          end
+
+          def subscribe(pattern)
+            return false if subscribers.key?(pattern)
+            subscribers[pattern] = ::ActiveSupport::Notifications.subscribe(pattern, self)
+            true
+          end
+
+          def unsubscribe(pattern)
+            return false unless subscribers.key?(pattern)
+            ::ActiveSupport::Notifications.unsubscribe(subscribers[pattern])
+            subscribers.delete(pattern)
+            true
+          end
+
+          def unsubscribe_all
+            return false if subscribers.empty?
+            subscribers.keys.each { |pattern| unsubscribe(pattern) }
+            true
+          end
+
+          protected
+
+          attr_reader \
+            :handler,
+            :callbacks
+
+          def start_span(name, id, payload, start = nil)
+            # Run callbacks
+            callbacks.run(name, :before_trace, id, payload, start)
+
+            # Start a trace
+            tracer.trace(@span_name, @options).tap do |span|
+              # Assign start time if provided
+              span.start_time = start unless start.nil?
+              payload[:datadog_span] = span
+            end
+          end
+
+          def finish_span(name, id, payload, finish = nil)
+            payload[:datadog_span].tap do |span|
+              # If no active span, return.
+              return nil if span.nil?
+
+              # Run handler for event
+              handler.run(span, name, id, payload)
+
+              # Finish the span
+              span.finish(finish)
+
+              # Run callbacks
+              callbacks.run(name, :after_trace, span, id, payload, finish)
+            end
+          end
+
+          # Pattern => ActiveSupport:Notifications::Subscribers
+          def subscribers
+            @subscribers ||= {}
+          end
+
+          # Wrapper for subscription handler
+          class Handler
+            attr_reader :block
+
+            def initialize(&block)
+              @block = block
+            end
+
+            def run(span, name, id, payload)
+              run!(span, name, id, payload)
+            rescue StandardError => e
+              Datadog::Tracer.log.debug("ActiveSupport::Notifications handler for '#{name}' failed: #{e.message}")
+            end
+
+            def run!(*args)
+              @block.call(*args)
+            end
+          end
+
+          # Wrapper for subscription callbacks
+          class Callbacks
+            attr_reader :blocks
+
+            def initialize
+              @blocks = {}
+            end
+
+            def add(key, &block)
+              blocks_for(key) << block if block_given?
+            end
+
+            def run(event, key, *args)
+              blocks_for(key).each do |callback|
+                begin
+                  callback.call(event, key, *args)
+                rescue StandardError => e
+                  Datadog::Tracer.log.debug(
+                    "ActiveSupport::Notifications '#{key}' callback for '#{event}' failed: #{e.message}"
+                  )
+                end
+              end
+            end
+
+            private
+
+            def blocks_for(key)
+              blocks[key] ||= []
+            end
+          end
+        end
+      end
+    end
+  end
+end