fair-ddtrace 0.8.2.a

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

@@ -0,0 +1,56 @@
+require 'ddtrace/ext/sql'
+
+require 'ddtrace/contrib/rails/utils'
+
+module Datadog
+  module Contrib
+    module Rails
+      # Code used to create and handle 'mysql.query', 'postgres.query', ... spans.
+      module ActiveRecord
+        def self.instrument
+          # ActiveRecord is instrumented only if it's available
+          return unless defined?(::ActiveRecord)
+
+          # 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
+          )
+
+          # find out if the SQL query has been cached in this request. This meta is really
+          # helpful to users because some spans may have 0ns of duration because the query
+          # is simply cached from memory, so the notification is fired with start == finish.
+          # TODO[manu]: this feature has been merged into master but has not yet released.
+          # We're supporting this action as a best effort, but we should add a test after
+          # a new version of Rails is out.
+          cached = payload[:cached]
+
+          # 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.set_tag('rails.db.cached', cached) if cached
+          span.start_time = start
+          span.finish(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,113 @@
+require 'thread'
+require 'ddtrace/ext/cache'
+
+module Datadog
+  module Contrib
+    module Rails
+      # Code used to create and handle 'rails.cache' spans.
+      module ActiveSupport
+        def self.instrument
+          # patch Rails core components
+          Datadog::RailsCachePatcher.patch_cache_store()
+
+          # 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
+            # discard parameters from the cache_store configuration
+            store, = *Array.wrap(::Rails.configuration.cache_store).flatten
+            span.set_tag('rails.cache.backend', store)
+            span.set_tag('rails.cache.key', payload.fetch(:key))
+            span.set_error(payload[:exception]) if payload[:exception]
+          ensure
+            span.start_time = start
+            span.finish(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,137 @@
+module Datadog
+  # RailsRendererPatcher contains function to patch Rails rendering libraries.
+  module RailsRendererPatcher
+    module_function
+
+    def patch_renderer
+      patch_renderer_render_template
+      patch_renderer_render_partial
+    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)
+          end
+        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)
+          end
+        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)
+          end
+        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)
+          end
+        end
+      end
+    end
+  end
+
+  # RailsCachePatcher contains function to patch Rails caching libraries.
+  module RailsCachePatcher
+    module_function
+
+    def patch_cache_store
+      patch_cache_store_read
+      patch_cache_store_fetch
+      patch_cache_store_write
+      patch_cache_store_delete
+      patch_cache_store_instrument
+    end
+
+    def cache_store_class(k)
+      # 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
+      c = if defined?(::ActiveSupport::Cache::RedisStore) &&
+             ::ActiveSupport::Cache::RedisStore.instance_methods(false).include?(k)
+            ::ActiveSupport::Cache::RedisStore
+          else
+            ::ActiveSupport::Cache::Store
+          end
+      c
+    end
+
+    def patch_cache_store_read
+      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)
+        end
+      end
+    end
+
+    def patch_cache_store_fetch
+      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)
+        end
+      end
+    end
+
+    def patch_cache_store_write
+      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)
+        end
+      end
+    end
+
+    def patch_cache_store_delete
+      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
+
+    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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+require 'ddtrace/pin'
+require 'ddtrace/ext/app_types'
+
+require 'ddtrace/contrib/grape/endpoint'
+require 'ddtrace/contrib/rack/middlewares'
+
+require 'ddtrace/contrib/rails/core_extensions'
+require 'ddtrace/contrib/rails/action_controller'
+require 'ddtrace/contrib/rails/action_view'
+require 'ddtrace/contrib/rails/active_record'
+require 'ddtrace/contrib/rails/active_support'
+require 'ddtrace/contrib/rails/utils'
+
+# Rails < 3.1
+if defined?(::ActiveRecord) && !defined?(::ActiveRecord::Base.connection_config)
+  ActiveRecord::Base.class_eval do
+    class << self
+      def connection_config
+        connection_pool.spec.config
+      end
+    end
+  end
+end
+
+module Datadog
+  module Contrib
+    # Instrument Rails.
+    module Rails
+      # Rails framework code, used to essentially:
+      # - handle configuration entries which are specific to Datadog tracing
+      # - instrument parts of the framework when needed
+      module Framework
+        # default configurations for the Rails integration; by default
+        # the Datadog.tracer is enabled, while the Rails auto instrumentation
+        # is kept disabled.
+        DEFAULT_CONFIG = {
+          enabled: true,
+          auto_instrument: false,
+          auto_instrument_redis: false,
+          auto_instrument_grape: false,
+          default_service: 'rails-app',
+          default_controller_service: 'rails-controller',
+          default_cache_service: 'rails-cache',
+          default_grape_service: 'grape',
+          template_base_path: 'views/',
+          tracer: Datadog.tracer,
+          debug: false,
+          trace_agent_hostname: Datadog::Writer::HOSTNAME,
+          trace_agent_port: Datadog::Writer::PORT,
+          env: nil,
+          tags: {}
+        }.freeze
+
+        # configure Datadog settings
+        # rubocop:disable Metrics/MethodLength
+        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 tracer tags
+          datadog_config[:tracer].set_tags(datadog_config[:tags])
+
+          datadog_config[:tracer].set_tags('env' => datadog_config[:env]) if datadog_config[:env]
+
+          # set default service details
+          datadog_config[:tracer].set_service_info(
+            datadog_config[:default_service],
+            'rack',
+            Datadog::Ext::AppTypes::WEB
+          )
+
+          datadog_config[:tracer].set_service_info(
+            datadog_config[:default_controller_service],
+            'rails',
+            Datadog::Ext::AppTypes::WEB
+          )
+
+          datadog_config[:tracer].set_service_info(
+            datadog_config[:default_cache_service],
+            'rails',
+            Datadog::Ext::AppTypes::CACHE
+          )
+
+          # By default, default service would be guessed from the script
+          # being executed, but here we know better, get it from Rails config.
+          datadog_config[:tracer].default_service = datadog_config[:default_service]
+
+          if defined?(::ActiveRecord)
+            begin
+              # set default database service details and store it in the configuration
+              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.warn("Unable to get database config (#{e}), skipping ActiveRecord instrumentation")
+            end
+          end
+
+          # update global configurations
+          ::Rails.configuration.datadog_trace = datadog_config
+        end
+
+        def self.auto_instrument_redis
+          return unless ::Rails.configuration.datadog_trace[:auto_instrument_redis]
+          Datadog::Tracer.log.debug('Enabling auto-instrumentation for Redis client')
+
+          # patch the Redis library and reload the CacheStore if it was using Redis
+          Datadog::Monkey.patch_module(:redis)
+
+          # reload the cache store if it's available and it's using Redis
+          return unless defined?(::ActiveSupport::Cache::RedisStore) &&
+                        defined?(::Rails.cache) &&
+                        ::Rails.cache.is_a?(::ActiveSupport::Cache::RedisStore)
+          Datadog::Tracer.log.debug('Enabling auto-instrumentation for redis-rails connector')
+
+          # backward compatibility: Rails 3.x doesn't have `cache=` method
+          cache_store = ::Rails.configuration.cache_store
+          cache_instance = ::ActiveSupport::Cache.lookup_store(cache_store)
+          if ::Rails::VERSION::MAJOR.to_i == 3
+            silence_warnings { Object.const_set 'RAILS_CACHE', cache_instance }
+          elsif ::Rails::VERSION::MAJOR.to_i > 3
+            ::Rails.cache = cache_instance
+          end
+        end
+
+        def self.auto_instrument_grape
+          return unless ::Rails.configuration.datadog_trace[:auto_instrument_grape]
+
+          # patch the Grape library so that endpoints are traced
+          Datadog::Monkey.patch_module(:grape)
+
+          # update the Grape pin object
+          pin = Datadog::Pin.get_from(::Grape)
+          return unless pin && pin.enabled?
+          pin.tracer = ::Rails.configuration.datadog_trace[:tracer]
+          pin.service = ::Rails.configuration.datadog_trace[:default_grape_service]
+        end
+
+        # automatically instrument all Rails component
+        def self.auto_instrument
+          return unless ::Rails.configuration.datadog_trace[:auto_instrument]
+          Datadog::Tracer.log.debug('Enabling auto-instrumentation for core components')
+
+          # instrumenting Rails framework
+          Datadog::Contrib::Rails::ActionController.instrument()
+          Datadog::Contrib::Rails::ActionView.instrument()
+          Datadog::Contrib::Rails::ActiveRecord.instrument()
+          Datadog::Contrib::Rails::ActiveSupport.instrument()
+        end
+      end
+    end
+  end
+end