ddtrace 0.26.1 → 0.27.0

data/docs/GettingStarted.md

@@ -26,13 +26,17 @@ To contribute, check out the [contribution guidelines][contribution docs] and [d
      - [Quickstart for OpenTracing](#quickstart-for-opentracing)
  - [Manual instrumentation](#manual-instrumentation)
  - [Integration instrumentation](#integration-instrumentation)
+     - [Action View](#action-view)
      - [Active Model Serializers](#active-model-serializers)
+     - [Action Pack](#action-pack)
      - [Active Record](#active-record)
+     - [Active Support](#active-support)
      - [AWS](#aws)
      - [Concurrent Ruby](#concurrent-ruby)
      - [Dalli](#dalli)
      - [DelayedJob](#delayedjob)
      - [Elastic Search](#elastic-search)
+     - [Ethon & Typhoeus](#ethon)
      - [Excon](#excon)
      - [Faraday](#faraday)
      - [Grape](#grape)
@@ -74,16 +78,18 @@ To contribute, check out the [contribution guidelines][contribution docs] and [d
 
 **Supported Ruby interpreters**:
 
-| Type  | Documentation              | Version | Support type |
-| ----- | -------------------------- | -----   | ------------ |
-| MRI   | https://www.ruby-lang.org/ | 1.9.1   | Deprecated   |
-|       |                            | 1.9.3   | Deprecated   |
-|       |                            | 2.0     | Full         |
-|       |                            | 2.1     | Full         |
-|       |                            | 2.2     | Full         |
-|       |                            | 2.3     | Full         |
-|       |                            | 2.4     | Full         |
-| JRuby | http://jruby.org/          | 9.1.5   | Experimental |
+| Type  | Documentation              | Version | Support type | Gem version support       | EOL Date         |
+| ----- | -------------------------- | -----   | ------------ | ------------------------- | ---------------- |
+| MRI   | https://www.ruby-lang.org/ | 1.9.1   | Maintenance  | < 0.27.0                  | August 6th, 2020 |
+|       |                            | 1.9.3   | Maintenance  | < 0.27.0                  | August 6th, 2020 |
+|       |                            | 2.0     | Full         | Latest                    | TBD              |
+|       |                            | 2.1     | Full         | Latest                    | TBD              |
+|       |                            | 2.2     | Full         | Latest                    | TBD              |
+|       |                            | 2.3     | Full         | Latest                    | TBD              |
+|       |                            | 2.4     | Full         | Latest                    | TBD              |
+|       |                            | 2.5     | Full         | Latest                    | TBD              |
+|       |                            | 2.6     | Full         | Latest                    | TBD              |
+| JRuby | http://jruby.org/          | 9.1.5   | Experimental | Latest                    | TBD              |
 
 **Supported web servers**:
 
@@ -105,6 +111,10 @@ To contribute, check out the [contribution guidelines][contribution docs] and [d
 
 *Deprecated* indicates support will be removed in a future release.
 
+*Maintenance* indicates only critical bugfixes are backported until EOL.
+
+*EOL* indicates support is no longer provided.
+
 ## Installation
 
 The following steps will help you quickly start tracing your Ruby application.
@@ -316,13 +326,17 @@ For a list of available integrations, and their configuration options, please re
 
 | Name                     | Key                        | Versions Supported       | How to configure                    | Gem source                                                                     |
 | ------------------------ | -------------------------- | ------------------------ | ----------------------------------- | ------------------------------------------------------------------------------ |
+| Action View              | `action_view`              | `>= 3.2, < 6.0`          | *[Link](#action-view)*              | *[Link](https://github.com/rails/rails/tree/master/actionview)*                |
 | Active Model Serializers | `active_model_serializers` | `>= 0.9`                 | *[Link](#active-model-serializers)* | *[Link](https://github.com/rails-api/active_model_serializers)*                |
+| Action Pack              | `action_pack`              | `>= 3.2, < 6.0`          | *[Link](#action-pack)*              | *[Link](https://github.com/rails/rails/tree/master/actionpack)*                |
 | Active Record            | `active_record`            | `>= 3.2, < 6.0`          | *[Link](#active-record)*            | *[Link](https://github.com/rails/rails/tree/master/activerecord)*              |
+| Active Support           | `active_support`           | `>= 3.2, < 6.0`          | *[Link](#active-support)*           | *[Link](https://github.com/rails/rails/tree/master/activesupport)*             |
 | AWS                      | `aws`                      | `>= 2.0`                 | *[Link](#aws)*                      | *[Link](https://github.com/aws/aws-sdk-ruby)*                                  |
 | Concurrent Ruby          | `concurrent_ruby`          | `>= 0.9`                 | *[Link](#concurrent-ruby)*          | *[Link](https://github.com/ruby-concurrency/concurrent-ruby)*                  |
 | Dalli                    | `dalli`                    | `>= 2.7`                 | *[Link](#dalli)*                    | *[Link](https://github.com/petergoldstein/dalli)*                              |
 | DelayedJob               | `delayed_job`              | `>= 4.1`                 | *[Link](#delayedjob)*               | *[Link](https://github.com/collectiveidea/delayed_job)*                        |
 | Elastic Search           | `elasticsearch`            | `>= 6.0`                 | *[Link](#elastic-search)*           | *[Link](https://github.com/elastic/elasticsearch-ruby)*                        |
+| Ethon                    | `ethon`                    | `>= 0.11.0`              | *[Link](#ethon)*                    | *[Link](https://github.com/typhoeus/ethon)*                                    |
 | Excon                    | `excon`                    | `>= 0.62`                | *[Link](#excon)*                    | *[Link](https://github.com/excon/excon)*                                       |
 | Faraday                  | `faraday`                  | `>= 0.14`                | *[Link](#faraday)*                  | *[Link](https://github.com/lostisland/faraday)*                                |
 | Grape                    | `grape`                    | `>= 1.0`                 | *[Link](#grape)*                    | *[Link](https://github.com/ruby-grape/grape)*                                  |
@@ -333,17 +347,39 @@ For a list of available integrations, and their configuration options, please re
 | Net/HTTP                 | `http`                     | *(Any supported Ruby)*   | *[Link](#nethttp)*                  | *[Link](https://ruby-doc.org/stdlib-2.4.0/libdoc/net/http/rdoc/Net/HTTP.html)* |
 | Racecar                  | `racecar`                  | `>= 0.3.5`               | *[Link](#racecar)*                  | *[Link](https://github.com/zendesk/racecar)*                                   |
 | Rack                     | `rack`                     | `>= 1.4.7`               | *[Link](#rack)*                     | *[Link](https://github.com/rack/rack)*                                         |
-| Rails                    | `rails`                    | `>= 3.2, <= 6.0`         | *[Link](#rails)*                    | *[Link](https://github.com/rails/rails)*                                       |
+| Rails                    | `rails`                    | `>= 3.2, < 6.0`         | *[Link](#rails)*                    | *[Link](https://github.com/rails/rails)*                                       |
 | Rake                     | `rake`                     | `>= 12.0`                | *[Link](#rake)*                     | *[Link](https://github.com/ruby/rake)*                                         |
 | Redis                    | `redis`                    | `>= 3.2, < 4.0`          | *[Link](#redis)*                    | *[Link](https://github.com/redis/redis-rb)*                                    |
 | Resque                   | `resque`                   | `>= 1.0, < 2.0`          | *[Link](#resque)*                   | *[Link](https://github.com/resque/resque)*                                     |
 | Rest Client              | `rest-client`              | `>= 1.8`                 | *[Link](#rest-client)*              | *[Link](https://github.com/rest-client/rest-client)*                           |
 | Sequel                   | `sequel`                   | `>= 3.41`                | *[Link](#sequel)*                   | *[Link](https://github.com/jeremyevans/sequel)*                                |
-| Shoryuken                | `shoryuken`                | `>= 4.0.2`               | *[Link](#shoryuken)*                | *[Link](https://github.com/phstc/shoryuken)*
+| Shoryuken                | `shoryuken`                | `>= 4.0.2`               | *[Link](#shoryuken)*                | *[Link](https://github.com/phstc/shoryuken)*                                   |
 | Sidekiq                  | `sidekiq`                  | `>= 3.5.4`               | *[Link](#sidekiq)*                  | *[Link](https://github.com/mperham/sidekiq)*                                   |
 | Sinatra                  | `sinatra`                  | `>= 1.4.5`               | *[Link](#sinatra)*                  | *[Link](https://github.com/sinatra/sinatra)*                                   |
 | Sucker Punch             | `sucker_punch`             | `>= 2.0`                 | *[Link](#sucker-punch)*             | *[Link](https://github.com/brandonhilkert/sucker_punch)*                       |
 
+### Action View
+
+Most of the time, Active Support is set up as part of Rails, but it can be activated separately:
+
+```ruby
+require 'actionview'
+require 'ddtrace'
+
+Datadog.configure do |c|
+  c.use :action_view, options
+end
+```
+
+Where `options` is an optional `Hash` that accepts the following parameters:
+
+| Key | Description | Default |
+| ---| --- | --- |
+| `analytics_enabled` | Enable analytics for spans produced by this integration. `true` for on, `nil` to defer to global setting, `false` for off. | `false` |
+| `service_name` | Service name used for rendering instrumentation. | `action_view` |
+| `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
+| `template_base_path` | Used when the template name is parsed. If you don't store your templates in the `views/` folder, you may need to change this value | `'views/'` |
+
 ### Active Model Serializers
 
 The Active Model Serializers integration traces the `serialize` event for version 0.9+ and the `render` event for version 0.10+.
@@ -366,6 +402,27 @@ ActiveModelSerializers::SerializableResource.new(test_obj).serializable_hash
 | `service_name` | Service name used for `active_model_serializers` instrumentation. | `'active_model_serializers'` |
 | `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
 
+### Action Pack
+
+Most of the time, Action Pack is set up as part of Rails, but it can be activated separately:
+
+```ruby
+require 'actionpack'
+require 'ddtrace'
+
+Datadog.configure do |c|
+  c.use :action_pack, options
+end
+```
+
+Where `options` is an optional `Hash` that accepts the following parameters:
+
+| Key | Description | Default |
+| ---| --- | --- |
+| `analytics_enabled` | Enable analytics for spans produced by this integration. `true` for on, `nil` to defer to global setting, `false` for off. | `false` |
+| `service_name` | Service name used for rendering instrumentation. | `action_pack` |
+| `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
+
 ### Active Record
 
 Most of the time, Active Record is set up as part of a web framework (Rails, Sinatra...) however, it can be set up alone:
@@ -434,6 +491,30 @@ end
 
 If ActiveRecord traces an event that uses a connection that matches a key defined by `describes`, it will use the trace settings assigned to that connection. If the connection does not match any of the described connections, it will use default settings defined by `c.use :active_record` instead.
 
+### Active Support
+
+Most of the time, Active Support is set up as part of Rails, but it can be activated separately:
+
+```ruby
+require 'activesupport'
+require 'ddtrace'
+
+Datadog.configure do |c|
+  c.use :active_support, options
+end
+
+cache = ActiveSupport::Cache::MemoryStore.new
+cache.read('city')
+```
+
+Where `options` is an optional `Hash` that accepts the following parameters:
+
+| Key | Description | Default |
+| ---| --- | --- |
+| `analytics_enabled` | Enable analytics for spans produced by this integration. `true` for on, `nil` to defer to global setting, `false` for off. | `false` |
+| `cache_service` | Service name used for caching with `active_support` instrumentation. | `active_support-cache` |
+| `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
+
 ### AWS
 
 The AWS integration will trace every interaction (e.g. API calls) with AWS services (S3, ElastiCache etc.).
@@ -559,6 +640,27 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 | `service_name` | Service name used for `elasticsearch` instrumentation | `'elasticsearch'` |
 | `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
 
+### Ethon
+
+The `ethon` integration will trace any HTTP request through `Easy` or `Multi` objects. Note that this integration also supports `Typhoeus` library which is based on `Ethon`.
+
+```ruby
+require 'ddtrace'
+
+Datadog.configure do |c|
+  c.use :ethon, options
+end
+```
+
+Where `options` is an optional `Hash` that accepts the following parameters:
+
+| Key | Description | Default |
+| --- | ----------- | ------- |
+| `analytics_enabled` | Enable analytics for spans produced by this integration. `true` for on, `nil` to defer to global setting, `false` for off. | `false` |
+| `distributed_tracing` | Enables [distributed tracing](#distributed-tracing) | `true` |
+| `service_name` | Service name for `ethon` instrumentation. | `'ethon'` |
+| `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
+
 ### Excon
 
 The `excon` integration is available through the `ddtrace` middleware:
@@ -1000,10 +1102,11 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 
 | Ruby Versions | Supported Rails Versions |
 | ------------- | ------------------------ |
-|  1.9.3 - 2.0  |  3.0 - 3.2               |
+|  2.0          |  3.0 - 3.2               |
 |  2.1          |  3.0 - 4.2               |
 |  2.2 - 2.3    |  3.0 - 5.2               |
 |  2.4 - 2.5    |  4.2.8 - 5.2             |
+|  2.6          |  5.0 - 5.2               |
 
 ### Rake
 
@@ -1499,7 +1602,7 @@ Service B:
   Priority:  1
 
   |
-  | Service B HTTP Request:
+  | Service C HTTP Request:
   |   Headers:
   |     x-datadog-trace-id:          100000000000000001
   |     x-datadog-parent-id:         100000000000000456

data/lib/ddtrace.rb

@@ -21,13 +21,17 @@ module Datadog
   extend Contrib::Extensions
 end
 
+require 'ddtrace/contrib/action_pack/integration'
+require 'ddtrace/contrib/action_view/integration'
 require 'ddtrace/contrib/active_model_serializers/integration'
 require 'ddtrace/contrib/active_record/integration'
+require 'ddtrace/contrib/active_support/integration'
 require 'ddtrace/contrib/aws/integration'
 require 'ddtrace/contrib/concurrent_ruby/integration'
 require 'ddtrace/contrib/dalli/integration'
 require 'ddtrace/contrib/delayed_job/integration'
 require 'ddtrace/contrib/elasticsearch/integration'
+require 'ddtrace/contrib/ethon/integration'
 require 'ddtrace/contrib/excon/integration'
 require 'ddtrace/contrib/faraday/integration'
 require 'ddtrace/contrib/grape/integration'

data/lib/ddtrace/analytics.rb

@@ -12,46 +12,16 @@ module Datadog
 
     # Extension for Datadog::Span
     module Span
-      def self.included(base)
-        if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0.0')
-          base.class_eval do
-            # Instance methods
-            include InstanceMethodsCompatibility
-            include InstanceMethods
-          end
+      def set_tag(key, value)
+        case key
+        when Ext::Analytics::TAG_ENABLED
+          # If true, set rate to 1.0, otherwise set 0.0.
+          value = value == true ? Ext::Analytics::DEFAULT_SAMPLE_RATE : 0.0
+          Analytics.set_sample_rate(self, value)
+        when Ext::Analytics::TAG_SAMPLE_RATE
+          Analytics.set_sample_rate(self, value)
         else
-          base.send(:prepend, InstanceMethods)
-        end
-      end
-
-      # Compatibility shim for Rubies not supporting `.prepend`
-      module InstanceMethodsCompatibility
-        def self.included(base)
-          base.class_eval do
-            alias_method :set_tag_without_analytics, :set_tag
-            # DEV: When we stack multiple extensions the method might already be removed
-            remove_method :set_tag if method_defined?(:set_tag)
-          end
-        end
-
-        def set_tag(*args, &block)
-          set_tag_without_analytics(*args, &block)
-        end
-      end
-
-      # Instance methods
-      module InstanceMethods
-        def set_tag(key, value)
-          case key
-          when Ext::Analytics::TAG_ENABLED
-            # If true, set rate to 1.0, otherwise set 0.0.
-            value = value == true ? Ext::Analytics::DEFAULT_SAMPLE_RATE : 0.0
-            Analytics.set_sample_rate(self, value)
-          when Ext::Analytics::TAG_SAMPLE_RATE
-            Analytics.set_sample_rate(self, value)
-          else
-            super if defined?(super)
-          end
+          super if defined?(super)
         end
       end
     end

data/lib/ddtrace/configuration.rb

@@ -6,11 +6,6 @@ module Datadog
   module Configuration
     attr_writer :configuration
 
-    RUBY_19_DEPRECATION_WARNING = %(
-      Support for Ruby versions < 2.0 in dd-trace-rb is DEPRECATED.
-      Last version to support Ruby < 2.0 will be 0.26.x, which will only receive critical bugfixes to existing features.
-      Support for Ruby versions < 2.0 will be REMOVED with version 0.27.0.).freeze
-
     def configuration
       @configuration ||= Settings.new
     end
@@ -21,9 +16,6 @@ module Datadog
       else
         PinSetup.new(target, opts).call
       end
-
-      # Raise Ruby 1.9 deprecation warning, if necessary.
-      raise_ruby_19_deprecation_warning!
     end
 
     # Helper methods
@@ -34,16 +26,5 @@ module Datadog
     def runtime_metrics
       tracer.writer.runtime_metrics
     end
-
-    # TODO: Remove with version 0.27.0
-    def raise_ruby_19_deprecation_warning!
-      return unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
-
-      require 'ddtrace/patcher'
-
-      Datadog::Patcher.do_once(:ruby_19_deprecation_warning) do
-        Datadog::Tracer.log.warn(RUBY_19_DEPRECATION_WARNING)
-      end
-    end
   end
 end

data/lib/ddtrace/contrib/action_pack/action_controller/instrumentation.rb

@@ -0,0 +1,144 @@
+require 'ddtrace/ext/http'
+
+require 'ddtrace/contrib/action_pack/ext'
+require 'ddtrace/contrib/action_pack/utils'
+require 'ddtrace/contrib/rack/middlewares'
+
+module Datadog
+  module Contrib
+    module ActionPack
+      module ActionController
+        # Instrumentation for ActionController components
+        module Instrumentation
+          module_function
+
+          def start_processing(payload)
+            # trace the execution
+            tracer = Datadog.configuration[:action_pack][:tracer]
+            service = Datadog.configuration[:action_pack][:controller_service]
+            type = Datadog::Ext::HTTP::TYPE_INBOUND
+            span = tracer.trace(Ext::SPAN_ACTION_CONTROLLER, service: service, span_type: type)
+
+            # attach the current span to the tracing context
+            tracing_context = payload.fetch(:tracing_context)
+            tracing_context[:dd_request_span] = span
+          rescue StandardError => e
+            Datadog::Tracer.log.error(e.message)
+          end
+
+          def finish_processing(payload)
+            # retrieve the tracing context and the latest active span
+            tracing_context = payload.fetch(:tracing_context)
+            env = payload.fetch(:env)
+            span = tracing_context[:dd_request_span]
+            return unless span && !span.finished?
+
+            begin
+              # Set the resource name, if it's still the default name
+              if span.resource == span.name
+                span.resource = "#{payload.fetch(:controller)}##{payload.fetch(:action)}"
+              end
+
+              # Set the resource name of the Rack request span unless this is an exception controller.
+              unless exception_controller?(payload)
+                rack_request_span = env[Datadog::Contrib::Rack::TraceMiddleware::RACK_REQUEST_SPAN]
+                rack_request_span.resource = span.resource if rack_request_span
+              end
+
+              # Set analytics sample rate
+              Utils.set_analytics_sample_rate(span)
+
+              # Associate with runtime metrics
+              Datadog.runtime_metrics.associate_with_span(span)
+
+              span.set_tag(Ext::TAG_ROUTE_ACTION, payload.fetch(:action))
+              span.set_tag(Ext::TAG_ROUTE_CONTROLLER, payload.fetch(:controller))
+
+              exception = payload[:exception_object]
+              if exception.nil?
+                # [christian] in some cases :status is not defined,
+                # rather than firing an error, simply acknowledge we don't know it.
+                status = payload.fetch(:status, '?').to_s
+                span.status = 1 if status.starts_with?('5')
+              elsif Utils.exception_is_error?(exception)
+                span.set_error(exception)
+              end
+            ensure
+              span.finish
+            end
+          rescue StandardError => e
+            Datadog::Tracer.log.error(e.message)
+          end
+
+          def exception_controller?(payload)
+            exception_controller_class = Datadog.configuration[:action_pack][:exception_controller]
+            controller = payload.fetch(:controller)
+            headers = payload.fetch(:headers)
+
+            # If no exception controller class has been set,
+            # guess whether this is an exception controller from the headers.
+            if exception_controller_class.nil?
+              !headers[:request_exception].nil?
+            # If an exception controller class has been specified,
+            # check if the controller is a kind of the exception controller class.
+            elsif exception_controller_class.is_a?(Class) || exception_controller_class.is_a?(Module)
+              controller <= exception_controller_class
+            # Otherwise if the exception controller class is some other value (like false)
+            # assume that this controller doesn't handle exceptions.
+            else
+              false
+            end
+          end
+
+          # Instrumentation for ActionController::Metal
+          module Metal
+            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,
+                env: request.env,
+                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
+                Instrumentation.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
+              Instrumentation.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
+end