ddtrace 0.12.0 → 0.12.1

data/docs/GettingStarted.md

@@ -221,6 +221,16 @@ def finish(name, id, payload)
   end
 end
 ```
+#####Enriching traces from nested methods
+
+You can tag additional information to current active span from any method. Note however that if the method is called and there is no span currently active `active_span` will be nil. 
+
+```ruby
+# e.g. adding tag to active span
+    
+current_span = Datadog.tracer.active_span
+current_span.set_tag('my_tag', 'my_value') unless current_span.nil?
+```
 
 ## Integration instrumentation
 
@@ -514,8 +524,10 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 
 | Key | Description | Default |
 | --- | --- | --- |
-| ``service_name`` | Service name used for `http` instrumentation | http |
+| ``service_name`` | Service name used for `http` instrumentation | net/http |
 | ``distributed_tracing`` | Enables distributed tracing | ``false`` |
+| ``tracer`` | A ``Datadog::Tracer`` instance used to instrument the application. Usually you don't need to set that. | ``Datadog.tracer`` |
+
 
 If you wish to configure each connection object individually, you may use the ``Datadog.configure`` as it follows:
 

data/gemfiles/contrib_old.gemfile

@@ -9,6 +9,7 @@ gem "redis", "< 4.0"
 gem "hiredis"
 gem "rack", "1.4.7"
 gem "rack-test", "0.7.0"
+gem "rack-cache", "1.7.1"
 gem "sinatra", "1.4.5"
 gem "sqlite3"
 gem "activerecord", "3.2.22.5"

data/gemfiles/rails30_postgres.gemfile

@@ -7,5 +7,6 @@ gem "test-unit"
 gem "rails", "3.0.20"
 gem "pg", "0.15.1", platform: :ruby
 gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
+gem "rack-cache", "1.7.1"
 
 gemspec path: "../"

data/gemfiles/rails30_postgres_sidekiq.gemfile

@@ -8,5 +8,6 @@ gem "rails", "3.0.20"
 gem "pg", "0.15.1", platform: :ruby
 gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
 gem "sidekiq", "4.0.0"
+gem "rack-cache", "1.7.1"
 
 gemspec path: "../"

data/gemfiles/rails32_mysql2.gemfile

@@ -8,5 +8,6 @@ gem "rails", "3.2.22.5"
 gem "mysql2", "0.3.21", platform: :ruby
 gem "activerecord-mysql-adapter", platform: :ruby
 gem "activerecord-jdbcmysql-adapter", platform: :jruby
+gem "rack-cache", "1.7.1"
 
 gemspec path: "../"

data/gemfiles/rails32_postgres.gemfile

@@ -7,5 +7,6 @@ gem "test-unit"
 gem "rails", "3.2.22.5"
 gem "pg", "0.15.1", platform: :ruby
 gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
+gem "rack-cache", "1.7.1"
 
 gemspec path: "../"

data/gemfiles/rails32_postgres_redis.gemfile

@@ -9,5 +9,6 @@ gem "pg", "0.15.1", platform: :ruby
 gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
 gem "redis-rails"
 gem "redis", "< 4.0"
+gem "rack-cache", "1.7.1"
 
 gemspec path: "../"

data/gemfiles/rails32_postgres_sidekiq.gemfile

@@ -8,5 +8,6 @@ gem "rails", "3.2.22.5"
 gem "pg", "0.15.1", platform: :ruby
 gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
 gem "sidekiq", "4.0.0"
+gem "rack-cache", "1.7.1"
 
 gemspec path: "../"

data/gemfiles/rails5_mysql2.gemfile

@@ -3,7 +3,7 @@
 source "https://rubygems.org"
 
 gem "pry-nav", git: "https://github.com/nixme/pry-nav.git", branch: "master"
-gem "rails", "5.1.5"
+gem "rails", "~> 5.1.6"
 gem "mysql2", "< 0.5", platform: :ruby
 
 gemspec path: "../"

data/gemfiles/rails5_postgres.gemfile

@@ -3,7 +3,7 @@
 source "https://rubygems.org"
 
 gem "pry-nav", git: "https://github.com/nixme/pry-nav.git", branch: "master"
-gem "rails", "5.1.5"
+gem "rails", "~> 5.1.6"
 gem "pg", "< 1.0", platform: :ruby
 
 gemspec path: "../"

data/gemfiles/rails5_postgres_redis.gemfile

@@ -3,7 +3,7 @@
 source "https://rubygems.org"
 
 gem "pry-nav", git: "https://github.com/nixme/pry-nav.git", branch: "master"
-gem "rails", "5.1.5"
+gem "rails", "~> 5.1.6"
 gem "pg", "< 1.0", platform: :ruby
 gem "redis-rails"
 gem "redis"

data/gemfiles/rails5_postgres_sidekiq.gemfile

@@ -3,7 +3,7 @@
 source "https://rubygems.org"
 
 gem "pry-nav", git: "https://github.com/nixme/pry-nav.git", branch: "master"
-gem "rails", "5.1.5"
+gem "rails", "~> 5.1.6"
 gem "pg", "< 1.0", platform: :ruby
 gem "sidekiq"
 gem "activejob"

data/lib/ddtrace/configuration.rb

@@ -9,11 +9,11 @@ module Datadog
 
     def initialize(options = {})
       @registry = options.fetch(:registry, Datadog.registry)
+      @wrapped_registry = {}
     end
 
     def [](integration_name)
-      integration = fetch_integration(integration_name)
-      Proxy.new(integration)
+      @wrapped_registry[integration_name] ||= Proxy.new(fetch_integration(integration_name))
     end
 
     def use(integration_name, options = {})

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

@@ -89,13 +89,13 @@ module Datadog
           # 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.
-          cached = payload[:cached] || (payload[:name] == 'CACHE')
+          cached = payload[:cached] || (payload[:name] == 'CACHE'.freeze)
 
-          span.set_tag('active_record.db.vendor', connection_config[:adapter_name])
-          span.set_tag('active_record.db.name', connection_config[:database_name])
-          span.set_tag('active_record.db.cached', cached) if cached
-          span.set_tag('out.host', connection_config[:adapter_host])
-          span.set_tag('out.port', connection_config[:adapter_port])
+          span.set_tag('active_record.db.vendor'.freeze, connection_config[:adapter_name])
+          span.set_tag('active_record.db.name'.freeze, connection_config[:database_name])
+          span.set_tag('active_record.db.cached'.freeze, cached) if cached
+          span.set_tag('out.host'.freeze, connection_config[:adapter_host])
+          span.set_tag('out.port'.freeze, connection_config[:adapter_port])
         rescue StandardError => e
           Datadog::Tracer.log.debug(e.message)
         end
@@ -107,13 +107,13 @@ module Datadog
                          elsif span.parent
                            span.parent.service
                          else
-                           'active_record'
+                           'active_record'.freeze
                          end
 
           span.resource = payload.fetch(:class_name)
-          span.span_type = 'custom'
-          span.set_tag('active_record.instantiation.class_name', payload.fetch(:class_name))
-          span.set_tag('active_record.instantiation.record_count', payload.fetch(:record_count))
+          span.span_type = 'custom'.freeze
+          span.set_tag('active_record.instantiation.class_name'.freeze, payload.fetch(:class_name))
+          span.set_tag('active_record.instantiation.record_count'.freeze, payload.fetch(:record_count))
         rescue StandardError => e
           Datadog::Tracer.log.debug(e.message)
         end

data/lib/ddtrace/contrib/aws/instrumentation.rb

@@ -27,8 +27,8 @@ module Datadog
         def annotate!(span, pin, context)
           span.service = pin.service
           span.span_type = pin.app_type
-          span.name = context.safely(:resource)
-          span.resource = RESOURCE
+          span.name = RESOURCE
+          span.resource = context.safely(:resource)
           span.set_tag('aws.agent', AGENT)
           span.set_tag('aws.operation', context.safely(:operation))
           span.set_tag('aws.region', context.safely(:region))

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

@@ -52,11 +52,11 @@ module Datadog
               remove_method :initialize
             end
 
-            def initialize(*args)
+            def initialize(*args, &block)
               service = Datadog.configuration[:elasticsearch][:service_name]
               pin = Datadog::Pin.new(service, app: 'elasticsearch', app_type: Datadog::Ext::AppTypes::DB)
               pin.onto(self)
-              initialize_without_datadog(*args)
+              initialize_without_datadog(*args, &block)
             end
 
             alias_method :perform_request_without_datadog, :perform_request

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

@@ -48,6 +48,8 @@ module Datadog
         include Base
         register_as :http, auto_patch: true
         option :distributed_tracing, default: false
+        option :service_name, default: SERVICE
+        option :tracer, default: Datadog.tracer
 
         @patched = false
 
@@ -64,7 +66,7 @@ module Datadog
               require 'ddtrace/ext/net'
               require 'ddtrace/ext/distributed'
 
-              patch_http()
+              patch_http
 
               @patched = true
             rescue StandardError => e
@@ -74,7 +76,7 @@ module Datadog
           @patched
         end
 
-        # patched? tells wether patch has been successfully applied
+        # patched? tells whether patch has been successfully applied
         def patched?
           @patched
         end
@@ -84,27 +86,27 @@ module Datadog
         # rubocop:disable Metrics/AbcSize
         def patch_http
           ::Net::HTTP.class_eval do
-            alias_method :initialize_without_datadog, :initialize
-            Datadog::Patcher.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 datadog_pin
+              @datadog_pindatadog_pin ||= begin
+                service = Datadog.configuration[:http][:service_name]
+                tracer = Datadog.configuration[:http][:tracer]
+
+                Datadog::Pin.new(service, app: APP, app_type: Datadog::Ext::AppTypes::WEB, tracer: tracer)
+              end
+            end
+
             def request(req, body = nil, &block) # :yield: +response+
-              pin = Datadog::Pin.get_from(self)
+              pin = datadog_pin
               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)
+
+              if Datadog::Contrib::HTTP.should_skip_tracing?(req, @address, @port, transport, pin)
+                return request_without_datadog(req, body, &block)
+              end
 
               pin.tracer.trace(NAME) do |span|
                 begin

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

@@ -0,0 +1,77 @@
+module Datadog
+  module Contrib
+    module Rails
+      # Instrument ActiveController processing
+      module ActionControllerPatch
+        def self.included(base)
+          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0.0')
+            base.send(:prepend, ProcessActionPatch)
+          else
+            base.class_eval do
+              alias_method :process_action_without_datadog, :process_action
+
+              include ProcessActionPatch
+            end
+          end
+        end
+
+        # Compatibility module for Ruby versions not supporting #prepend
+        module ProcessActionCompatibilityPatch
+          def process_action(*args)
+            process_action_without_datadog(*args)
+          end
+        end
+
+        # ActionController patch
+        module ProcessActionPatch
+          # compatibility module for Ruby versions not supporting #prepend
+          include ProcessActionCompatibilityPatch unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0.0')
+
+          def process_action(*args)
+            # mutable payload with a tracing context that is used in two different
+            # signals; it propagates the request span so that it can be finished
+            # no matter what
+            payload = {
+              controller: self.class,
+              action: action_name,
+              headers: {
+                # The exception this controller was given in the request,
+                # which is typical if the controller is configured to handle exceptions.
+                request_exception: request.headers['action_dispatch.exception']
+              },
+              tracing_context: {}
+            }
+
+            begin
+              # process and catch request exceptions
+              Datadog::Contrib::Rails::ActionController.start_processing(payload)
+              result = super(*args)
+              status = datadog_response_status
+              payload[:status] = status unless status.nil?
+              result
+            # rubocop:disable Lint/RescueException
+            rescue Exception => e
+              payload[:exception] = [e.class.name, e.message]
+              payload[:exception_object] = e
+              raise e
+            end
+          # rubocop:enable Lint/RescueException
+          ensure
+            Datadog::Contrib::Rails::ActionController.finish_processing(payload)
+          end
+
+          def datadog_response_status
+            case response
+            when ActionDispatch::Response
+              response.status
+            when Array
+              # Likely a Rack response array: first element is the status.
+              status = response.first
+              status.class <= Integer ? status : nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,71 +13,6 @@ module Datadog
             Datadog::RailsRendererPatcher.patch_renderer
           end
         end
-
-        def self.start_render_template(payload)
-          # retrieve the tracing context
-          tracing_context = payload.fetch(:tracing_context)
-
-          # create a new Span and add it to the tracing context
-          tracer = Datadog.configuration[:rails][:tracer]
-          span = tracer.trace('rails.render_template', span_type: Datadog::Ext::HTTP::TEMPLATE)
-          tracing_context[:dd_rails_template_span] = span
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
-
-        def self.finish_render_template(payload)
-          # retrieve the tracing context and the latest active span
-          tracing_context = payload.fetch(:tracing_context)
-          span = tracing_context[:dd_rails_template_span]
-          return if !span || span.finished?
-
-          # finish the tracing and update the execution time
-          begin
-            template_name = tracing_context[:template_name]
-            layout = tracing_context[:layout]
-            exception = tracing_context[:exception]
-
-            span.set_tag('rails.template_name', template_name) if template_name
-            span.set_tag('rails.layout', layout) if layout
-            span.set_error(exception) if exception
-          ensure
-            span.finish()
-          end
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
-
-        def self.start_render_partial(payload)
-          # retrieve the tracing context
-          tracing_context = payload.fetch(:tracing_context)
-
-          tracer = Datadog.configuration[:rails][:tracer]
-          span = tracer.trace('rails.render_partial', span_type: Datadog::Ext::HTTP::TEMPLATE)
-          tracing_context[:dd_rails_partial_span] = span
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
-
-        def self.finish_render_partial(payload)
-          # retrieve the tracing context and the latest active span
-          tracing_context = payload.fetch(:tracing_context)
-          span = tracing_context[:dd_rails_partial_span]
-          return if !span || span.finished?
-
-          # finish the tracing and update the execution time
-          begin
-            template_name = tracing_context[:template_name]
-            exception = tracing_context[:exception]
-
-            span.set_tag('rails.template_name', template_name) if template_name
-            span.set_error(exception) if exception
-          ensure
-            span.finish()
-          end
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
       end
     end
   end

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

@@ -17,7 +17,6 @@ module Datadog
 
         def self.start_trace_cache(payload)
           tracer = Datadog.configuration[:rails][:tracer]
-          tracing_context = payload.fetch(:tracing_context)
 
           # 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
@@ -25,14 +24,16 @@ module Datadog
           # 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 current_span.try('name') == 'rails.cache' &&
-                    current_span.try('resource') == 'GET' &&
-                    payload[:action] == 'GET'
+          return if payload[:action] == 'GET'.freeze &&
+                    current_span.try(:name) == 'rails.cache'.freeze &&
+                    current_span.try(:resource) == 'GET'.freeze
+
+          tracing_context = payload.fetch(:tracing_context)
 
           # create a new ``Span`` and add it to the tracing context
           service = Datadog.configuration[:rails][:cache_service]
           type = Datadog::Ext::CACHE::TYPE
-          span = tracer.trace('rails.cache', service: service, span_type: type)
+          span = tracer.trace('rails.cache'.freeze, service: service, span_type: type)
           span.resource = payload.fetch(:action)
           tracing_context[:dd_cache_span] = span
         rescue StandardError => e
@@ -48,12 +49,12 @@ module Datadog
           begin
             # 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.backend'.freeze, store)
             cache_key = Datadog::Utils.truncate(payload.fetch(:key), Ext::CACHE::MAX_KEY_SIZE)
-            span.set_tag('rails.cache.key', cache_key)
+            span.set_tag('rails.cache.key'.freeze, cache_key)
             span.set_error(payload[:exception]) if payload[:exception]
           ensure
-            span.finish()
+            span.finish
           end
         rescue StandardError => e
           Datadog::Tracer.log.debug(e.message)