ddtrace 0.3.1

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

@@ -0,0 +1,44 @@
+require 'ddtrace/ext/sql'
+
+require 'ddtrace/contrib/rails/utils'
+
+module Datadog
+  module Contrib
+    module Rails
+      # TODO[manu]: write docs
+      module ActiveRecord
+        def self.instrument
+          # subscribe when the active record query has been processed
+          ::ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
+            sql(*args)
+          end
+        end
+
+        def self.sql(_name, start, finish, _id, payload)
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          database_service = ::Rails.configuration.datadog_trace.fetch(:default_database_service)
+          adapter_name = ::ActiveRecord::Base.connection_config[:adapter]
+          adapter_name = Datadog::Contrib::Rails::Utils.normalize_vendor(adapter_name)
+          span_type = Datadog::Ext::SQL::TYPE
+
+          span = tracer.trace(
+            "#{adapter_name}.query",
+            resource: payload.fetch(:sql),
+            service: database_service,
+            span_type: span_type
+          )
+
+          # the span should have the query ONLY in the Resource attribute,
+          # so that the ``sql.query`` tag will be set in the agent with an
+          # obfuscated version
+          span.span_type = Datadog::Ext::SQL::TYPE
+          span.set_tag('rails.db.vendor', adapter_name)
+          span.start_time = start
+          span.finish_at(finish)
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+require 'thread'
+require 'ddtrace/ext/cache'
+
+module Datadog
+  module Contrib
+    module Rails
+      # TODO[manu]: write docs
+      module ActiveSupport
+        def self.instrument
+          # subscribe when a cache read starts being processed
+          ::ActiveSupport::Notifications.subscribe('start_cache_read.active_support') do |*args|
+            start_trace_cache('GET', *args)
+          end
+
+          # subscribe when a cache fetch starts being processed
+          ::ActiveSupport::Notifications.subscribe('start_cache_fetch.active_support') do |*args|
+            start_trace_cache('GET', *args)
+          end
+
+          # subscribe when a cache write starts being processed
+          ::ActiveSupport::Notifications.subscribe('start_cache_write.active_support') do |*args|
+            start_trace_cache('SET', *args)
+          end
+
+          # subscribe when a cache delete starts being processed
+          ::ActiveSupport::Notifications.subscribe('start_cache_delete.active_support') do |*args|
+            start_trace_cache('DELETE', *args)
+          end
+
+          # subscribe when a cache read has been processed
+          ::ActiveSupport::Notifications.subscribe('cache_read.active_support') do |*args|
+            trace_cache('GET', *args)
+          end
+
+          # subscribe when a cache write has been processed
+          ::ActiveSupport::Notifications.subscribe('cache_write.active_support') do |*args|
+            trace_cache('SET', *args)
+          end
+
+          # subscribe when a cache delete has been processed
+          ::ActiveSupport::Notifications.subscribe('cache_delete.active_support') do |*args|
+            trace_cache('DELETE', *args)
+          end
+        end
+
+        def self.create_span(tracer)
+          service = ::Rails.configuration.datadog_trace.fetch(:default_cache_service)
+          type = Datadog::Ext::CACHE::TYPE
+          tracer.trace('rails.cache', service: service, span_type: type)
+        end
+
+        def self.get_key(resource)
+          'datadog_activesupport_' + resource
+        end
+
+        def self.start_trace_cache(resource, *_args)
+          key = get_key(resource)
+          # This is mostly to trap the case of fetch/read. In some cases the framework
+          # will call fetch but fetch won't call read. In some cases read can be called
+          # alone. And in some cases they are nested. In all cases we want to have one
+          # and only one span.
+          return if Thread.current[key]
+          create_span(::Rails.configuration.datadog_trace.fetch(:tracer))
+          Thread.current[key] = true
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.trace_cache(resource, _name, start, finish, _id, payload)
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          key = get_key(resource)
+          if Thread.current[key]
+            # span was created by start_trace_cache, plan to re-use this one
+            Thread.current[key] = false
+          else
+            # Create a span now, as start_trace_cache was not called.
+            #
+            # This could typically happen if, for some reason the monkey-patching
+            # of the cache class did not work as expected. Doing this, we might
+            # loose some interesting parentship between some spans, because this
+            # span is created too late, and children won't "find" their parent.
+            # But, it's better than no span at all, and it case there is no child
+            # at all, it will work just as expected. In practice, it's required to
+            # have standard file cache work together with redis cache.
+            create_span(tracer)
+          end
+          span = tracer.active_span()
+          return unless span
+
+          begin
+            # finish the tracing and update the execution time
+            span.resource = resource
+            span.set_tag('rails.cache.backend', ::Rails.configuration.cache_store)
+            span.set_tag('rails.cache.key', payload.fetch(:key))
+
+            if payload[:exception]
+              error = payload[:exception]
+              span.status = 1
+              span.set_tag(Datadog::Ext::Errors::TYPE, error[0])
+              span.set_tag(Datadog::Ext::Errors::MSG, error[1])
+            end
+
+          ensure
+            span.start_time = start
+            span.finish_at(finish)
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        private_class_method :create_span, :get_key, :start_trace_cache, :trace_cache
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module Datadog
+  # TODO[manu]: write docs
+  module RendererExtension
+    def render_template(*args)
+      ActiveSupport::Notifications.instrument('start_render_template.action_view')
+      super(*args)
+    end
+  end
+
+  # TODO[manu]: write docs
+  module PartialRendererExtension
+    def render_partial(*args)
+      ActiveSupport::Notifications.instrument('start_render_partial.action_view')
+      super(*args)
+    end
+  end
+
+  # CacheStoreReadExtension contains a new read function that notifies
+  # the framework of a read, then calls read.
+  module CacheStoreReadExtension
+    def read(*args)
+      ActiveSupport::Notifications.instrument('start_cache_read.active_support')
+      super(*args)
+    end
+  end
+
+  # CacheStoreFetchExtension contains a new fetch function that notifies
+  # the framework of a fetch, then calls fetch.
+  module CacheStoreFetchExtension
+    # It might seem redundant to instrument both read and fetch since
+    # fetch very often calls read. But there's no garantee of this, in
+    # some cases fetch can call directly read_entry without calling read.
+    def fetch(*args)
+      ActiveSupport::Notifications.instrument('start_cache_fetch.active_support')
+      super(*args)
+    end
+  end
+
+  # CacheWriteReadExtension contains a new read function that notifies
+  # the framework of a write, then calls write.
+  module CacheStoreWriteExtension
+    def write(*args)
+      ActiveSupport::Notifications.instrument('start_cache_write.active_support')
+      super(*args)
+    end
+  end
+
+  # CacheDeleteExtension contains a new read function that notifies
+  # the framework of a delete, then calls delete.
+  module CacheStoreDeleteExtension
+    def delete(*args)
+      ActiveSupport::Notifications.instrument('start_cache_delete.active_support')
+      super(*args)
+    end
+  end
+
+  # RailsPatcher contains function to patch the Rails libraries.
+  module RailsPatcher
+    module_function
+
+    def patch_renderer
+      ::ActionView::Renderer.prepend Datadog::RendererExtension
+      ::ActionView::PartialRenderer.prepend Datadog::PartialRendererExtension
+    end
+
+    def patch_cache_store
+      # 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
+
+      { read: Datadog::CacheStoreReadExtension,
+        fetch: Datadog::CacheStoreFetchExtension,
+        write: Datadog::CacheStoreWriteExtension,
+        delete: Datadog::CacheStoreDeleteExtension }.each do |k, v|
+        c = if defined?(::ActiveSupport::Cache::RedisStore) &&
+               ::ActiveSupport::Cache::RedisStore.instance_methods(false).include?(k)
+              ::ActiveSupport::Cache::RedisStore
+            else
+              ::ActiveSupport::Cache::Store
+            end
+        Datadog::Tracer.log.debug("monkey patching #{c}.#{k} with #{v}.#{k}")
+        c.prepend v
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+require 'ddtrace'
+require 'ddtrace/ext/app_types'
+
+require 'ddtrace/contrib/rails/core_extensions'
+require 'ddtrace/contrib/rails/action_controller'
+require 'ddtrace/contrib/rails/action_view'
+require 'ddtrace/contrib/rails/active_record' if defined?(::ActiveRecord)
+require 'ddtrace/contrib/rails/active_support'
+require 'ddtrace/contrib/rails/utils'
+
+module Datadog
+  module Contrib
+    # TODO[manu]: write docs
+    module Rails
+      # TODO[manu]: write docs
+      module Framework
+        # the default configuration
+        DEFAULT_CONFIG = {
+          enabled: true,
+          auto_instrument: true,
+          auto_instrument_redis: true,
+          default_service: 'rails-app',
+          default_cache_service: 'rails-cache',
+          template_base_path: 'views/',
+          tracer: Datadog.tracer,
+          debug: false,
+          trace_agent_hostname: Datadog::Writer::HOSTNAME,
+          trace_agent_port: Datadog::Writer::PORT
+        }.freeze
+
+        # configure Datadog settings
+        def self.configure(config)
+          # tracer defaults
+          # merge default configurations with users settings
+          user_config = config[:config].datadog_trace rescue {}
+          datadog_config = DEFAULT_CONFIG.merge(user_config)
+          datadog_config[:tracer].enabled = datadog_config[:enabled]
+
+          # set debug logging
+          Datadog::Tracer.debug_logging = datadog_config[:debug]
+
+          # set the address of the trace agent
+          datadog_config[:tracer].configure(
+            hostname: datadog_config[:trace_agent_hostname],
+            port: datadog_config[:trace_agent_port]
+          )
+
+          # set default service details
+          datadog_config[:tracer].set_service_info(
+            datadog_config[:default_service],
+            'rails',
+            Datadog::Ext::AppTypes::WEB
+          )
+          datadog_config[:tracer].set_service_info(
+            datadog_config[:default_cache_service],
+            'rails',
+            Datadog::Ext::AppTypes::CACHE
+          )
+
+          # set default database service details and store it in the configuration
+          if defined?(::ActiveRecord)
+            begin
+              conn_cfg = ::ActiveRecord::Base.connection_config()
+              adapter_name = Datadog::Contrib::Rails::Utils.normalize_vendor(conn_cfg[:adapter])
+              database_service = datadog_config.fetch(:default_database_service, adapter_name)
+              datadog_config[:default_database_service] = database_service
+              datadog_config[:tracer].set_service_info(
+                database_service,
+                adapter_name,
+                Datadog::Ext::AppTypes::DB
+              )
+            rescue StandardError => e
+              Datadog::Tracer.log.info("cannot configuring database service (#{e}), skipping activerecord instrumentation")
+            end
+          end
+
+          # update global configurations
+          ::Rails.configuration.datadog_trace = datadog_config
+        end
+
+        def self.auto_instrument_redis
+          Datadog::Tracer.log.debug('instrumenting redis')
+          return unless (defined? ::Rails.cache) && ::Rails.cache.respond_to?(:data)
+          Datadog::Tracer.log.debug('redis cache exists')
+          pin = Datadog::Pin.get_from(::Rails.cache.data)
+          return unless pin
+          Datadog::Tracer.log.debug('redis cache pin is set')
+          pin.tracer = nil unless ::Rails.configuration.datadog_trace[:auto_instrument_redis]
+        end
+
+        # automatically instrument all Rails component
+        def self.auto_instrument
+          return unless ::Rails.configuration.datadog_trace[:auto_instrument]
+          Datadog::Tracer.log.info('Detected Rails >= 3.x. Enabling auto-instrumentation for core components.')
+          Datadog::Contrib::Rails::ActionController.instrument()
+          Datadog::Contrib::Rails::ActionView.instrument()
+          Datadog::Contrib::Rails::ActiveRecord.instrument() if defined?(::ActiveRecord)
+          Datadog::Contrib::Rails::ActiveSupport.instrument()
+
+          # by default, Rails 3 doesn't instrument the cache system
+          return unless ::Rails::VERSION::MAJOR.to_i == 3
+          ::ActiveSupport::Cache::Store.instrument = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Datadog
+  module Contrib
+    module Rails
+      # common utilities for Rails
+      module Utils
+        # 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 self.normalize_template_name(name)
+          return if name.nil?
+
+          base_path = ::Rails.configuration.datadog_trace.fetch(:template_base_path, 'views/')
+          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
+
+        # Return a canonical name for a type of database
+        def self.normalize_vendor(vendor)
+          case vendor
+          when nil
+            'defaultdb'
+          when 'sqlite3'
+            'sqlite'
+          when 'postgresql'
+            'postgres'
+          else
+            vendor
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/redis/tags'
+require 'ddtrace/contrib/redis/quantize'
+
+module Datadog
+  module Contrib
+    module Redis
+      SERVICE = 'redis'.freeze
+
+      DRIVER = 'redis.driver'.freeze
+
+      # TracedRedis is a wrapper so that caller can pin on parent object without knowing about client member.
+      module TracedRedis
+        def datadog_pin=(pin)
+          # Forward the pin to client, which actually traces calls.
+          Datadog::Pin.onto(client, pin)
+        end
+
+        def datadog_pin
+          # Get the pin from client, which actually traces calls.
+          Datadog::Pin.get_from(client)
+        end
+      end
+
+      # Datadog APM Redis integration.
+      module TracedRedisClient
+        def initialize(*args)
+          pin = Datadog::Pin.new(SERVICE, app: 'redis', app_type: Datadog::Ext::AppTypes::DB)
+          pin.onto(self)
+          super(*args)
+        end
+
+        def call(*args, &block)
+          pin = Datadog::Pin.get_from(self)
+          return super(*args, &block) unless pin
+
+          response = nil
+          pin.tracer.trace('redis.command') do |span|
+            span.service = pin.service
+            span.span_type = Datadog::Ext::Redis::TYPE
+            span.resource = Datadog::Contrib::Redis::Quantize.format_command_args(*args)
+            span.set_tag(Datadog::Ext::Redis::RAWCMD, span.resource)
+            Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
+
+            response = super(*args, &block)
+          end
+
+          response
+        end
+
+        def call_pipeline(*args, &block)
+          pin = Datadog::Pin.get_from(self)
+          return super(*args, &block) unless pin
+
+          response = nil
+          pin.tracer.trace('redis.command') do |span|
+            span.service = pin.service
+            span.span_type = Datadog::Ext::Redis::TYPE
+            commands = args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.format_command_args(c) }
+            span.resource = commands.join("\n")
+            span.set_tag(Datadog::Ext::Redis::RAWCMD, span.resource)
+            Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
+
+            response = super(*args, &block)
+          end
+
+          response
+        end
+      end
+    end
+  end
+end