ddtrace 0.26.1 → 0.27.0

data/lib/ddtrace/contrib/ethon/configuration/settings.rb

@@ -0,0 +1,24 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/ethon/ext'
+
+module Datadog
+  module Contrib
+    module Ethon
+      module Configuration
+        # Custom settings for the Ethon integration
+        class Settings < Contrib::Configuration::Settings
+          option  :analytics_enabled,
+                  default: -> { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) },
+                  lazy: true
+
+          option  :analytics_sample_rate,
+                  default: -> { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) },
+                  lazy: true
+
+          option :distributed_tracing, default: true
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/ethon/easy_patch.rb

@@ -0,0 +1,139 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/distributed'
+require 'ddtrace/propagation/http_propagator'
+require 'ddtrace/contrib/ethon/ext'
+
+module Datadog
+  module Contrib
+    module Ethon
+      # Ethon EasyPatch
+      module EasyPatch
+        def self.included(base)
+          base.send(:prepend, InstanceMethods)
+        end
+
+        # InstanceMethods - implementing instrumentation
+        module InstanceMethods
+          def http_request(url, action_name, options = {})
+            return super unless tracer_enabled?
+
+            # It's tricky to get HTTP method from libcurl
+            @datadog_method = action_name.to_s.upcase
+            super
+          end
+
+          def headers=(headers)
+            return super unless tracer_enabled?
+
+            # Store headers to call this method again when span is ready
+            @datadog_original_headers = headers
+            super
+          end
+
+          def perform
+            return super unless tracer_enabled?
+            datadog_before_request
+            super
+          end
+
+          def complete
+            return super unless tracer_enabled?
+            begin
+              response_options = mirror.options
+              response_code = (response_options[:response_code] || response_options[:code]).to_i
+              if response_code.zero?
+                return_code = response_options[:return_code]
+                message = return_code ? ::Ethon::Curl.easy_strerror(return_code) : 'unknown reason'
+                set_span_error_message("Request has failed: #{message}")
+              else
+                @datadog_span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response_code)
+                if Datadog::Ext::HTTP::ERROR_RANGE.cover?(response_code)
+                  set_span_error_message("Request has failed with HTTP error: #{response_code}")
+                end
+              end
+            ensure
+              @datadog_span.finish
+              @datadog_span = nil
+            end
+            super
+          end
+
+          def reset
+            super
+          ensure
+            if tracer_enabled?
+              @datadog_span = nil
+              @datadog_method = nil
+              @datadog_original_headers = nil
+            end
+          end
+
+          def datadog_before_request(parent_span: nil)
+            @datadog_span = datadog_configuration[:tracer].trace(
+              Ext::SPAN_REQUEST,
+              service: datadog_configuration[:service_name],
+              span_type: Datadog::Ext::HTTP::TYPE_OUTBOUND
+            )
+            @datadog_span.parent = parent_span unless parent_span.nil?
+
+            datadog_tag_request
+
+            if datadog_configuration[:distributed_tracing]
+              @datadog_original_headers ||= {}
+              Datadog::HTTPPropagator.inject!(@datadog_span.context, @datadog_original_headers)
+              self.headers = @datadog_original_headers
+            end
+          end
+
+          def datadog_span_started?
+            instance_variable_defined?(:@datadog_span) && !@datadog_span.nil?
+          end
+
+          private
+
+          def datadog_tag_request
+            span = @datadog_span
+            uri = URI.parse(url)
+            method = 'N/A'
+            if instance_variable_defined?(:@datadog_method) && !@datadog_method.nil?
+              method = @datadog_method.to_s
+            end
+            span.resource = method
+
+            # Set analytics sample rate
+            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+            span.set_tag(Datadog::Ext::HTTP::URL, uri.path)
+            span.set_tag(Datadog::Ext::HTTP::METHOD, method)
+            span.set_tag(Datadog::Ext::NET::TARGET_HOST, uri.host)
+            span.set_tag(Datadog::Ext::NET::TARGET_PORT, uri.port)
+          rescue URI::InvalidURIError
+            return
+          end
+
+          def set_span_error_message(message)
+            # Sets span error from message, in case there is no exception available
+            @datadog_span.status = Datadog::Ext::Errors::STATUS
+            @datadog_span.set_tag(Datadog::Ext::Errors::MSG, message)
+          end
+
+          def datadog_configuration
+            Datadog.configuration[:ethon]
+          end
+
+          def tracer_enabled?
+            datadog_configuration[:tracer].enabled
+          end
+
+          def analytics_enabled?
+            Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+          end
+
+          def analytics_sample_rate
+            datadog_configuration[:analytics_sample_rate]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/ethon/ext.rb

@@ -0,0 +1,15 @@
+module Datadog
+  module Contrib
+    module Ethon
+      # Ethon integration constants
+      module Ext
+        APP = 'ethon'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_ETHON_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_ETHON_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'ethon'.freeze
+        SPAN_REQUEST = 'ethon.request'.freeze
+        SPAN_MULTI_REQUEST = 'ethon.multi.request'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/ethon/integration.rb

@@ -0,0 +1,35 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/ethon/configuration/settings'
+require 'ddtrace/contrib/ethon/patcher'
+
+module Datadog
+  module Contrib
+    module Ethon
+      # Description of Ethon integration
+      class Integration
+        include Contrib::Integration
+        register_as :ethon
+
+        def self.version
+          Gem.loaded_specs['ethon'] && Gem.loaded_specs['ethon'].version
+        end
+
+        def self.present?
+          super && defined?(::Ethon::Easy)
+        end
+
+        def self.compatible?
+          super && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0.0')
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/ethon/multi_patch.rb

@@ -0,0 +1,80 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/distributed'
+require 'ddtrace/propagation/http_propagator'
+require 'ddtrace/contrib/ethon/ext'
+
+module Datadog
+  module Contrib
+    module Ethon
+      # Ethon MultiPatch
+      module MultiPatch
+        def self.included(base)
+          # No need to prepend here since add method is included into Multi class
+          base.send(:include, InstanceMethods)
+        end
+
+        # InstanceMethods - implementing instrumentation
+        module InstanceMethods
+          def add(easy)
+            handles = super
+            return handles if handles.nil? || !tracer_enabled?
+
+            if datadog_multi_performing?
+              # Start Easy span in case Multi is already performing
+              easy.datadog_before_request(parent_span: datadog_multi_span)
+            end
+            handles
+          end
+
+          def perform
+            if tracer_enabled?
+              easy_handles.each do |easy|
+                easy.datadog_before_request(parent_span: datadog_multi_span) unless easy.datadog_span_started?
+              end
+            end
+            super
+          ensure
+            if tracer_enabled? && datadog_multi_performing?
+              @datadog_multi_span.finish
+              @datadog_multi_span = nil
+            end
+          end
+
+          private
+
+          def datadog_multi_performing?
+            instance_variable_defined?(:@datadog_multi_span) && !@datadog_multi_span.nil?
+          end
+
+          def datadog_multi_span
+            @datadog_multi_span ||= datadog_configuration[:tracer].trace(
+              Ext::SPAN_MULTI_REQUEST,
+              service: datadog_configuration[:service_name]
+            )
+
+            # Set analytics sample rate
+            Contrib::Analytics.set_sample_rate(@datadog_multi_span, analytics_sample_rate) if analytics_enabled?
+
+            @datadog_multi_span
+          end
+
+          def datadog_configuration
+            Datadog.configuration[:ethon]
+          end
+
+          def tracer_enabled?
+            datadog_configuration[:tracer].enabled
+          end
+
+          def analytics_enabled?
+            Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+          end
+
+          def analytics_sample_rate
+            datadog_configuration[:analytics_sample_rate]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Datadog
+  module Contrib
+    module Ethon
+      # Patcher enables patching of 'ethon' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:ethon)
+        end
+
+        def patch
+          do_once(:ethon) do
+            require 'ddtrace/ext/app_types'
+            require 'ddtrace/contrib/ethon/easy_patch'
+            require 'ddtrace/contrib/ethon/multi_patch'
+
+            ::Ethon::Easy.send(:include, EasyPatch)
+            ::Ethon::Multi.send(:include, MultiPatch)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/patchable.rb

@@ -18,7 +18,7 @@ module Datadog
         end
 
         def compatible?
-          RUBY_VERSION >= '1.9.3' && present?
+          Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0.0') && present?
         end
       end
 

data/lib/ddtrace/contrib/rails/configuration/settings.rb

@@ -8,14 +8,34 @@ module Datadog
         class Settings < Contrib::Configuration::Settings
           option  :analytics_enabled,
                   default: -> { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, nil) },
-                  lazy: true
+                  lazy: true do |value|
+            value.tap do
+              # Update ActionPack analytics too
+              Datadog.configuration[:action_pack][:analytics_enabled] = value
+            end
+          end
 
           option  :analytics_sample_rate,
                   default: -> { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) },
-                  lazy: true
+                  lazy: true do |value|
+            value.tap do
+              # Update ActionPack analytics too
+              Datadog.configuration[:action_pack][:analytics_sample_rate] = value
+            end
+          end
 
-          option :cache_service
-          option :controller_service
+          option :cache_service do |value|
+            value.tap do
+              # Update ActiveSupport service name too
+              Datadog.configuration[:active_support][:cache_service] = value
+            end
+          end
+          option :controller_service do |value|
+            value.tap do
+              # Update ActionPack service name too
+              Datadog.configuration[:action_pack][:controller_service] = value
+            end
+          end
           option :database_service, depends_on: [:service_name] do |value|
             value.tap do
               # Update ActiveRecord service name too
@@ -23,10 +43,27 @@ module Datadog
             end
           end
           option :distributed_tracing, default: true
-          option :exception_controller, default: nil
+          option :exception_controller, default: nil do |value|
+            value.tap do
+              # Update ActionPack exception controller too
+              Datadog.configuration[:action_pack][:exception_controller] = value
+            end
+          end
           option :middleware, default: true
           option :middleware_names, default: false
-          option :template_base_path, default: 'views/'
+          option :template_base_path, default: 'views/' do |value|
+            # Update ActionView template base path too
+            value.tap { Datadog.configuration[:action_view][:template_base_path] = value }
+          end
+
+          option :tracer, default: Datadog.tracer do |value|
+            value.tap do
+              Datadog.configuration[:active_record][:tracer] = value
+              Datadog.configuration[:active_support][:tracer] = value
+              Datadog.configuration[:action_pack][:tracer] = value
+              Datadog.configuration[:action_view][:tracer] = value
+            end
+          end
         end
       end
     end

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

@@ -6,21 +6,6 @@ module Datadog
         APP = 'rails'.freeze
         ENV_ANALYTICS_ENABLED = 'DD_RAILS_ANALYTICS_ENABLED'.freeze
         ENV_ANALYTICS_SAMPLE_RATE = 'DD_RAILS_ANALYTICS_SAMPLE_RATE'.freeze
-        QUANTIZE_CACHE_MAX_KEY_SIZE = 300
-        RESOURCE_CACHE_DELETE = 'DELETE'.freeze
-        RESOURCE_CACHE_GET = 'GET'.freeze
-        RESOURCE_CACHE_SET = 'SET'.freeze
-        SPAN_ACTION_CONTROLLER = 'rails.action_controller'.freeze
-        SPAN_CACHE = 'rails.cache'.freeze
-        SPAN_RENDER_PARTIAL = 'rails.render_partial'.freeze
-        SPAN_RENDER_TEMPLATE = 'rails.render_template'.freeze
-        SPAN_TYPE_CACHE = 'cache'.freeze
-        TAG_CACHE_BACKEND = 'rails.cache.backend'.freeze
-        TAG_CACHE_KEY = 'rails.cache.key'.freeze
-        TAG_LAYOUT = 'rails.layout'.freeze
-        TAG_ROUTE_ACTION = 'rails.route.action'.freeze
-        TAG_ROUTE_CONTROLLER = 'rails.route.controller'.freeze
-        TAG_TEMPLATE_NAME = 'rails.template_name'.freeze
       end
     end
   end

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

@@ -1,15 +1,13 @@
 require 'ddtrace/pin'
 require 'ddtrace/ext/app_types'
 
-require 'ddtrace/contrib/active_record/patcher'
+require 'ddtrace/contrib/active_record/integration'
+require 'ddtrace/contrib/active_support/integration'
+require 'ddtrace/contrib/action_pack/integration'
+require 'ddtrace/contrib/action_view/integration'
 require 'ddtrace/contrib/grape/endpoint'
-require 'ddtrace/contrib/rack/middlewares'
 
 require 'ddtrace/contrib/rails/ext'
-require 'ddtrace/contrib/rails/core_extensions'
-require 'ddtrace/contrib/rails/action_controller'
-require 'ddtrace/contrib/rails/action_view'
-require 'ddtrace/contrib/rails/active_support'
 require 'ddtrace/contrib/rails/utils'
 
 module Datadog
@@ -25,6 +23,9 @@ module Datadog
           config = config_with_defaults
 
           activate_rack!(config)
+          activate_active_support!(config)
+          activate_action_pack!(config)
+          activate_action_view!(config)
           activate_active_record!(config)
 
           # By default, default service would be guessed from the script
@@ -54,6 +55,36 @@ module Datadog
           )
         end
 
+        def self.activate_active_support!(config)
+          return unless defined?(::ActiveSupport)
+
+          Datadog.configuration.use(
+            :active_support,
+            cache_service: config[:cache_service],
+            tracer: config[:tracer]
+          )
+        end
+
+        def self.activate_action_pack!(config)
+          return unless defined?(::ActionPack)
+
+          Datadog.configuration.use(
+            :action_pack,
+            service_name: config[:service_name],
+            tracer: config[:tracer]
+          )
+        end
+
+        def self.activate_action_view!(config)
+          return unless defined?(::ActionView)
+
+          Datadog.configuration.use(
+            :action_view,
+            service_name: config[:service_name],
+            tracer: config[:tracer]
+          )
+        end
+
         def self.activate_active_record!(config)
           return unless defined?(::ActiveRecord)