ddtrace 0.3.1 → 0.4.0

data/gemfiles/rails5_mysql2.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "rails", "5.0.0.1"
+gem "rails", "5.0.1"
 gem "mysql2", :platform => :ruby
 
 gemspec :path => "../"

data/gemfiles/rails5_postgres.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "rails", "5.0.0.1"
+gem "rails", "5.0.1"
 gem "pg", :platform => :ruby
 
 gemspec :path => "../"

data/gemfiles/rails5_postgres_redis.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "rails", "5.0.0.1"
+gem "rails", "5.0.1"
 gem "pg", :platform => :ruby
 gem "redis-rails"
 

data/lib/ddtrace.rb

@@ -28,25 +28,27 @@ end
 # Datadog auto instrumentation for frameworks
 if defined?(Rails::VERSION)
   if Rails::VERSION::MAJOR.to_i >= 3
-    begin
-      # We include 'redis-rails' here if it's available, doing it later
-      # (typically in initialize callback) does not work, it does not
-      # get loaded in the right context.
-      require 'redis-rails'
-      Datadog::Tracer.log.info("'redis-rails' module found, datadog redis integration is available")
-    rescue LoadError
-      Datadog::Tracer.log.info("no 'redis-rails' module found, datadog redis integration is not available")
-    end
     require 'ddtrace/contrib/rails/framework'
 
-    Datadog::Monkey.patch_module(:redis) # does nothing if redis is not loaded
-    Datadog::RailsPatcher.patch_renderer()
-    Datadog::RailsPatcher.patch_cache_store()
-
     module Datadog
       # Run the auto instrumentation directly after the initialization of the application and
       # after the application initializers in config/initializers are run
       class Railtie < Rails::Railtie
+        config.before_configuration do
+          begin
+            # We include 'redis-rails' here if it's available, doing it later
+            # (typically in initialize callback) does not work, it does not
+            # get loaded in the right context.
+            require 'redis-rails'
+            Datadog::Tracer.log.debug("'redis-rails' module found, Datadog 'redis-rails' integration is available")
+          rescue LoadError
+            Datadog::Tracer.log.debug("'redis-rails' module not found, Datadog 'redis-rails' integration is disabled")
+          end
+
+          Datadog::Monkey.patch_module(:redis)
+        end
+
+        # we do actions
         config.after_initialize do |app|
           Datadog::Contrib::Rails::Framework.configure(config: app.config)
           Datadog::Contrib::Rails::Framework.auto_instrument()

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

@@ -17,14 +17,16 @@ module Datadog
 
       # Datadog APM Elastic Search integration.
       module TracedClient
-        def initialize(*args)
+        def initialize(*)
           pin = Datadog::Pin.new(SERVICE, app: 'elasticsearch', app_type: Datadog::Ext::AppTypes::DB)
           pin.onto(self)
-          super(*args)
+          super
         end
 
         def perform_request(*args)
           pin = Datadog::Pin.get_from(self)
+          return super unless pin && pin.tracer
+
           method = args[0]
           path = args[1]
           params = args[2]

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

@@ -0,0 +1,131 @@
+# requirements should be kept minimal as Patcher is a shared requirement.
+
+module Datadog
+  module Contrib
+    # Datadog Net/HTTP integration.
+    module HTTP
+      URL = 'http.url'.freeze
+      METHOD = 'http.method'.freeze
+      BODY = 'http.body'.freeze
+
+      NAME = 'http.request'.freeze
+      APP = 'net/http'.freeze
+      SERVICE = 'net/http'.freeze
+
+      module_function
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      def should_skip_tracing?(req, address, port, transport, pin)
+        # we don't want to trace our own call to the API (they use net/http)
+        # when we know the host & port (from the URI) we use it, else (most-likely
+        # called with a block) rely on the URL at the end.
+        if req.uri
+          if req.uri.host.to_s == transport.hostname.to_s &&
+             req.uri.port.to_i == transport.port.to_i
+            return true
+          end
+        elsif address && port &&
+              address.to_s == transport.hostname.to_s &&
+              port.to_i == transport.port.to_i
+          return true
+        end
+        # we don't want a "shotgun" effect with two nested traces for one
+        # logical get, and request is likely to call itself recursively
+        active = pin.tracer.active_span()
+        return true if active && (active.name == NAME)
+        false
+      end
+
+      # Patcher enables patching of 'net/http' module.
+      # This is used in monkey.rb to automatically apply patches
+      module Patcher
+        @patched = false
+
+        module_function
+
+        # patch applies our patch if needed
+        def patch
+          unless @patched
+            begin
+              require 'uri'
+              require 'ddtrace/pin'
+              require 'ddtrace/monkey'
+              require 'ddtrace/ext/app_types'
+              require 'ddtrace/ext/http'
+              require 'ddtrace/ext/net'
+
+              patch_http()
+
+              @patched = true
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply net/http integration: #{e}")
+            end
+          end
+          @patched
+        end
+
+        # patched? tells wether patch has been successfully applied
+        def patched?
+          @patched
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def patch_http
+          ::Net::HTTP.class_eval do
+            alias_method :initialize_without_datadog, :initialize
+            Datadog::Monkey.without_warnings do
+              remove_method :initialize
+            end
+
+            def initialize(*args)
+              pin = Datadog::Pin.new(SERVICE, app: APP, app_type: Datadog::Ext::AppTypes::WEB)
+              pin.onto(self)
+              initialize_without_datadog(*args)
+            end
+
+            alias_method :request_without_datadog, :request
+            remove_method :request
+            def request(req, body = nil, &block) # :yield: +response+
+              pin = Datadog::Pin.get_from(self)
+              return request_without_datadog(req, body, &block) unless pin && pin.tracer
+
+              transport = pin.tracer.writer.transport
+              return request_without_datadog(req, body, &block) if
+                Datadog::Contrib::HTTP.should_skip_tracing?(req, @address, @port, transport, pin)
+
+              pin.tracer.trace(NAME) do |span|
+                span.service = pin.service
+                span.span_type = Datadog::Ext::HTTP::TYPE
+
+                span.resource = req.path
+                # *NOT* filling Datadog::Ext::HTTP::URL as it's already in resource.
+                # The agent can then decide to quantize the URL and store the original,
+                # untouched data in http.url but the client should not send redundant fields.
+                span.set_tag(Datadog::Ext::HTTP::METHOD, req.method)
+                response = request_without_datadog(req, body, &block)
+                span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.code)
+                if req.uri
+                  span.set_tag(Datadog::Ext::NET::TARGET_HOST, req.uri.host)
+                  span.set_tag(Datadog::Ext::NET::TARGET_PORT, req.uri.port.to_s)
+                else
+                  span.set_tag(Datadog::Ext::NET::TARGET_HOST, @address)
+                  span.set_tag(Datadog::Ext::NET::TARGET_PORT, @port.to_s)
+                end
+
+                case response.code.to_i / 100
+                when 4
+                  span.set_error(response)
+                when 5
+                  span.set_error(response)
+                end
+
+                response
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,9 @@ module Datadog
       # TODO[manu]: write docs
       module ActionView
         def self.instrument
+          # patch Rails core components
+          Datadog::RailsPatcher.patch_renderer()
+
           # subscribe when the template rendering starts
           ::ActiveSupport::Notifications.subscribe('start_render_template.action_view') do |*args|
             start_render_template(*args)

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

@@ -8,6 +8,9 @@ module Datadog
       # TODO[manu]: write docs
       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)

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

@@ -7,6 +7,9 @@ module Datadog
       # TODO[manu]: write docs
       module ActiveSupport
         def self.instrument
+          # patch Rails core components
+          Datadog::RailsPatcher.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)

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

@@ -54,6 +54,15 @@ module Datadog
     end
   end
 
+  # CacheInstrumentExtension prepends 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.
+  module CacheInstrumentExtension
+    def instrument
+      true
+    end
+  end
+
   # RailsPatcher contains function to patch the Rails libraries.
   module RailsPatcher
     module_function
@@ -84,6 +93,14 @@ module Datadog
         Datadog::Tracer.log.debug("monkey patching #{c}.#{k} with #{v}.#{k}")
         c.prepend v
       end
+
+      # 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.prepend Datadog::CacheInstrumentExtension
     end
   end
 end

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

@@ -1,10 +1,9 @@
-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_record'
 require 'ddtrace/contrib/rails/active_support'
 require 'ddtrace/contrib/rails/utils'
 
@@ -14,11 +13,13 @@ module Datadog
     module Rails
       # TODO[manu]: write docs
       module Framework
-        # the default configuration
+        # 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: true,
-          auto_instrument_redis: true,
+          auto_instrument: false,
+          auto_instrument_redis: false,
           default_service: 'rails-app',
           default_cache_service: 'rails-cache',
           template_base_path: 'views/',
@@ -57,9 +58,9 @@ module Datadog
             Datadog::Ext::AppTypes::CACHE
           )
 
-          # set default database service details and store it in the configuration
           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)
@@ -70,7 +71,7 @@ module Datadog
                 Datadog::Ext::AppTypes::DB
               )
             rescue StandardError => e
-              Datadog::Tracer.log.info("cannot configuring database service (#{e}), skipping activerecord instrumentation")
+              Datadog::Tracer.log.warn("Unable to get database config (#{e}), skipping ActiveRecord instrumentation")
             end
           end
 
@@ -79,27 +80,27 @@ module Datadog
         end
 
         def self.auto_instrument_redis
-          Datadog::Tracer.log.debug('instrumenting redis')
+          # configure Redis PIN
           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')
+
+          # enable Redis instrumentation if activated
           pin.tracer = nil unless ::Rails.configuration.datadog_trace[:auto_instrument_redis]
+          return unless pin.tracer
+          Datadog::Tracer.log.debug("'redis' module found, Datadog 'redis' integration is available")
         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::Tracer.log.info('Detected Rails >= 3.x. Enabling auto-instrumentation for core components')
+
+          # instrumenting Rails framework
           Datadog::Contrib::Rails::ActionController.instrument()
           Datadog::Contrib::Rails::ActionView.instrument()
-          Datadog::Contrib::Rails::ActiveRecord.instrument() if defined?(::ActiveRecord)
+          Datadog::Contrib::Rails::ActiveRecord.instrument()
           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

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

@@ -3,6 +3,9 @@
 module Datadog
   module Contrib
     module Redis
+      SERVICE = 'redis'.freeze
+      DRIVER = 'redis.driver'.freeze
+
       # Patcher enables patching of 'redis' module.
       # This is used in monkey.rb to automatically apply patches
       module Patcher
@@ -15,9 +18,15 @@ module Datadog
           if !@patched && (defined?(::Redis::VERSION) && \
                            Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('3.0.0'))
             begin
-              require 'ddtrace/contrib/redis/core'
-              ::Redis.prepend Datadog::Contrib::Redis::TracedRedis
-              ::Redis::Client.prepend Datadog::Contrib::Redis::TracedRedisClient
+              # do not require these by default, but only when actually patching
+              require 'ddtrace/monkey'
+              require 'ddtrace/ext/app_types'
+              require 'ddtrace/contrib/redis/tags'
+              require 'ddtrace/contrib/redis/quantize'
+
+              patch_redis()
+              patch_redis_client()
+
               @patched = true
             rescue StandardError => e
               Datadog::Tracer.log.error("Unable to apply Redis integration: #{e}")
@@ -26,6 +35,77 @@ module Datadog
           @patched
         end
 
+        def patch_redis
+          ::Redis.module_eval do
+            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
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def patch_redis_client
+          ::Redis::Client.class_eval do
+            alias_method :initialize_without_datadog, :initialize
+            Datadog::Monkey.without_warnings do
+              remove_method :initialize
+            end
+
+            def initialize(*args)
+              pin = Datadog::Pin.new(SERVICE, app: 'redis', app_type: Datadog::Ext::AppTypes::DB)
+              pin.onto(self)
+              initialize_without_datadog(*args)
+            end
+
+            alias_method :call_without_datadog, :call
+            remove_method :call
+            def call(*args, &block)
+              pin = Datadog::Pin.get_from(self)
+              return call_without_datadog(*args, &block) unless pin && pin.tracer
+
+              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 = call_without_datadog(*args, &block)
+              end
+
+              response
+            end
+
+            alias_method :call_pipeline_without_datadog, :call_pipeline
+            remove_method :call_pipeline
+            def call_pipeline(*args, &block)
+              pin = Datadog::Pin.get_from(self)
+              return call_pipeline_without_datadog(*args, &block) unless pin && pin.tracer
+
+              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 = call_pipeline_without_datadog(*args, &block)
+              end
+
+              response
+            end
+          end
+        end
+
         # patched? tells wether patch has been successfully applied
         def patched?
           @patched