ls-trace 0.1.2 → 0.2.0

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

@@ -9,20 +9,13 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:excon)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:excon) do
-            begin
-              require 'ddtrace/contrib/excon/middleware'
-
-              add_middleware
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Excon integration: #{e}")
-            end
-          end
+          require 'ddtrace/contrib/excon/middleware'
+          add_middleware
         end
 
         def add_middleware

data/lib/ddtrace/contrib/extensions.rb

@@ -1,3 +1,4 @@
+require 'set'
 require 'ddtrace/contrib/registry'
 
 module Datadog
@@ -7,6 +8,7 @@ module Datadog
     module Extensions
       def self.extended(base)
         Datadog.send(:extend, Helpers)
+        Datadog.send(:extend, Configuration)
         Datadog::Configuration::Settings.send(:include, Configuration::Settings)
       end
 
@@ -17,7 +19,24 @@ module Datadog
         end
       end
 
+      # Configuration methods for Datadog module.
       module Configuration
+        def configure(target = configuration, opts = {})
+          # Reconfigure core settings
+          super
+
+          # Activate integrations
+          if target.respond_to?(:integrations_pending_activation)
+            target.integrations_pending_activation.each do |integration|
+              integration.patch if integration.respond_to?(:patch)
+            end
+
+            target.integrations_pending_activation.clear
+          end
+
+          target
+        end
+
         # Extensions for Datadog::Configuration::Settings
         module Settings
           InvalidIntegrationError = Class.new(StandardError)
@@ -34,22 +53,37 @@ module Datadog
             integration.configuration(configuration_name) unless integration.nil?
           end
 
-          def use(integration_name, options = {}, &block)
+          def instrument(integration_name, options = {}, &block)
             integration = fetch_integration(integration_name)
 
-            unless integration.nil?
+            unless integration.nil? || !integration.default_configuration.enabled
               configuration_name = options[:describes] || :default
               filtered_options = options.reject { |k, _v| k == :describes }
               integration.configure(configuration_name, filtered_options, &block)
+              instrumented_integrations[integration_name] = integration
+
+              # Add to activation list
+              integrations_pending_activation << integration
             end
+          end
+
+          alias_method :use, :instrument
 
-            integration.patch if integration.respond_to?(:patch)
+          def integrations_pending_activation
+            @integrations_pending_activation ||= Set.new
           end
 
-          private
+          def instrumented_integrations
+            @instrumented_integrations ||= {}
+          end
+
+          def reset!
+            instrumented_integrations.clear
+            super
+          end
 
           def fetch_integration(name)
-            get_option(:registry)[name] ||
+            registry[name] ||
               raise(InvalidIntegrationError, "'#{name}' is not a valid integration.")
           end
         end

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

@@ -12,13 +12,18 @@ module Datadog
             Datadog::Ext::HTTP::ERROR_RANGE.cover?(env[:status])
           end
 
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
           option :analytics_enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
             o.lazy
           end
 
           option :analytics_sample_rate do |o|
-            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
             o.lazy
           end
 

data/lib/ddtrace/contrib/faraday/connection.rb

@@ -0,0 +1,18 @@
+module Datadog
+  module Contrib
+    module Faraday
+      # Handles installation of our middleware if the user has *not*
+      # already explicitly configured our middleware for this correction.
+      #
+      # Wraps Faraday::Connection#initialize:
+      # https://github.com/lostisland/faraday/blob/ff9dc1d1219a1bbdba95a9a4cf5d135b97247ee2/lib/faraday/connection.rb#L62-L92
+      module Connection
+        def initialize(*args, &block)
+          super.tap do
+            use(:ddtrace) unless builder.handlers.any? { |h| h.klass == Middleware }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,8 +4,11 @@ module Datadog
       # Faraday integration constants
       module Ext
         APP = 'faraday'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_FARADAY_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_FARADAY_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ENABLED = 'DD_TRACE_FARADAY_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_FARADAY_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_FARADAY_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_FARADAY_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_FARADAY_ANALYTICS_SAMPLE_RATE'.freeze
         SERVICE_NAME = 'faraday'.freeze
         SPAN_REQUEST = 'faraday.request'.freeze
       end

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

@@ -1,4 +1,5 @@
 require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/configuration/resolvers/pattern_resolver'
 require 'ddtrace/contrib/faraday/configuration/settings'
 require 'ddtrace/contrib/faraday/patcher'
 
@@ -9,18 +10,20 @@ module Datadog
       class Integration
         include Contrib::Integration
 
+        MINIMUM_VERSION = Gem::Version.new('0.14.0')
+
         register_as :faraday, auto_patch: true
 
         def self.version
           Gem.loaded_specs['faraday'] && Gem.loaded_specs['faraday'].version
         end
 
-        def self.present?
-          super && defined?(::Faraday)
+        def self.loaded?
+          !defined?(::Faraday).nil?
         end
 
         def self.compatible?
-          super && version < Gem::Version.new('1.0.0')
+          super && version >= MINIMUM_VERSION
         end
 
         def default_configuration
@@ -30,6 +33,10 @@ module Datadog
         def patcher
           Patcher
         end
+
+        def resolver
+          @resolver ||= Contrib::Configuration::Resolvers::PatternResolver.new
+        end
       end
     end
   end

data/lib/ddtrace/contrib/faraday/middleware.rb

@@ -4,6 +4,7 @@ require 'ddtrace/ext/net'
 require 'ddtrace/propagation/http_propagator'
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/faraday/ext'
+require 'ddtrace/contrib/http_annotation_helper'
 
 module Datadog
   module Contrib
@@ -11,33 +12,38 @@ module Datadog
       # Middleware implements a faraday-middleware for ddtrace instrumentation
       class Middleware < ::Faraday::Middleware
         include Datadog::Ext::DistributedTracing
+        include Datadog::Contrib::HttpAnnotationHelper
 
         def initialize(app, options = {})
           super(app)
-          @options = datadog_configuration.options_hash.merge(options)
-          setup_service!
+          @options = options
         end
 
         def call(env)
-          tracer.trace(Ext::SPAN_REQUEST) do |span|
-            annotate!(span, env)
-            propagate!(span, env) if options[:distributed_tracing] && tracer.enabled
-            app.call(env).on_complete { |resp| handle_response(span, resp) }
+          # Resolve configuration settings to use for this request.
+          # Do this once to reduce expensive regex calls.
+          request_options = build_request_options!(env)
+
+          request_options[:tracer].trace(Ext::SPAN_REQUEST) do |span|
+            annotate!(span, env, request_options)
+            propagate!(span, env) if request_options[:distributed_tracing] && request_options[:tracer].enabled
+            app.call(env).on_complete { |resp| handle_response(span, resp, request_options) }
           end
         end
 
         private
 
-        attr_reader :app, :options
+        attr_reader :app
 
-        def annotate!(span, env)
+        def annotate!(span, env, options)
           span.resource = resource_name(env)
-          span.service = service_name(env)
+          service_name(env[:url].host, options)
+          span.service = options[:split_by_domain] ? env[:url].host : options[:service_name]
           span.span_type = Datadog::Ext::HTTP::TYPE_OUTBOUND
 
           # Set analytics sample rate
-          if analytics_enabled?
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
+          if Contrib::Analytics.enabled?(options[:analytics_enabled])
+            Contrib::Analytics.set_sample_rate(span, options[:analytics_sample_rate])
           end
 
           span.set_tag(Datadog::Ext::HTTP::URL, env[:url].path)
@@ -46,7 +52,7 @@ module Datadog
           span.set_tag(Datadog::Ext::NET::TARGET_PORT, env[:url].port)
         end
 
-        def handle_response(span, env)
+        def handle_response(span, env, options)
           if options.fetch(:error_handler).call(env)
             span.set_error(["Error #{env[:status]}", env[:body]])
           end
@@ -58,34 +64,18 @@ module Datadog
           Datadog::HTTPPropagator.inject!(span.context, env[:request_headers])
         end
 
-        def datadog_configuration
-          Datadog.configuration[:faraday]
-        end
-
-        def tracer
-          options[:tracer]
-        end
-
-        def service_name(env)
-          return env[:url].host if options[:split_by_domain]
-
-          options[:service_name]
-        end
-
         def resource_name(env)
           env[:method].to_s.upcase
         end
 
-        def analytics_enabled?
-          Contrib::Analytics.enabled?(options[:analytics_enabled])
-        end
-
-        def analytics_sample_rate
-          options[:analytics_sample_rate]
+        def build_request_options!(env)
+          datadog_configuration.options_hash # integration level settings
+                               .merge(datadog_configuration(env[:url].host).options_hash) # per-host override
+                               .merge(@options) # middleware instance override
         end
 
-        def setup_service!
-          return if options[:service_name] == datadog_configuration[:service_name]
+        def datadog_configuration(host = :default)
+          Datadog.configuration[:faraday, host]
         end
       end
     end

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

@@ -1,6 +1,7 @@
 require 'ddtrace/contrib/patcher'
 require 'ddtrace/ext/app_types'
 require 'ddtrace/contrib/faraday/ext'
+require 'ddtrace/contrib/faraday/connection'
 require 'ddtrace/contrib/faraday/rack_builder'
 
 module Datadog
@@ -12,22 +13,16 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:faraday)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:faraday) do
-            begin
-              require 'ddtrace/contrib/faraday/middleware'
+          require 'ddtrace/contrib/faraday/middleware'
 
-              add_pin!
-              register_middleware!
-              add_default_middleware!
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Faraday integration: #{e}")
-            end
-          end
+          add_pin!
+          register_middleware!
+          add_default_middleware!
         end
 
         def add_pin!
@@ -36,7 +31,7 @@ module Datadog
               get_option(:service_name),
               app: Ext::APP,
               app_type: Datadog::Ext::AppTypes::WEB,
-              tracer: get_option(:tracer)
+              tracer: -> { get_option(:tracer) }
             ).onto(::Faraday)
         end
 
@@ -45,7 +40,23 @@ module Datadog
         end
 
         def add_default_middleware!
-          ::Faraday::RackBuilder.send(:prepend, RackBuilder)
+          if target_version >= Gem::Version.new('1.0.0')
+            # Patch the default connection (e.g. +Faraday.get+)
+            ::Faraday.default_connection.use(:ddtrace)
+
+            # Patch new connection instances (e.g. +Faraday.new+)
+            ::Faraday::Connection.send(:prepend, Connection)
+          else
+            # Patch the default connection (e.g. +Faraday.get+)
+            #
+            # We insert our middleware before the 'adapter', which is
+            # always the last handler.
+            idx = ::Faraday.default_connection.builder.handlers.size - 1
+            ::Faraday.default_connection.builder.insert(idx, Middleware)
+
+            # Patch new connection instances (e.g. +Faraday.new+)
+            ::Faraday::RackBuilder.send(:prepend, RackBuilder)
+          end
         end
 
         def get_option(option)
@@ -62,17 +73,13 @@ module Datadog
             Upgrade to the configuration API using the migration guide here:
             https://github.com/DataDog/dd-trace-rb/releases/tag/v0.11.0).freeze
 
-          def tracer=(tracer)
-            Datadog.configuration[:faraday][:tracer] = tracer
-          end
-
           def service_name=(service_name)
             Datadog.configuration[:faraday][:service_name] = service_name
           end
 
           def log_deprecation_warning(method_name)
             do_once(method_name) do
-              Datadog::Tracer.log.warn("#{method_name}:#{DEPRECATION_WARNING}")
+              Datadog.logger.warn("#{method_name}:#{DEPRECATION_WARNING}")
             end
           end
         end

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

@@ -8,17 +8,21 @@ module Datadog
       module Configuration
         # Custom settings for the Grape integration
         class Settings < Contrib::Configuration::Settings
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
           option :analytics_enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, nil) }
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], nil) }
             o.lazy
           end
 
           option :analytics_sample_rate do |o|
-            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
             o.lazy
           end
 
-          option :enabled, default: true
           option :service_name, default: Ext::SERVICE_NAME
         end
       end

data/lib/ddtrace/contrib/grape/endpoint.rb

@@ -46,7 +46,7 @@ module Datadog
 
             Thread.current[KEY_RUN] = true
           rescue StandardError => e
-            Datadog::Tracer.log.error(e.message)
+            Datadog.logger.error(e.message)
           end
 
           def endpoint_run(name, start, finish, id, payload)
@@ -85,6 +85,9 @@ module Datadog
                 Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
               end
 
+              # Measure service stats
+              Contrib::Analytics.set_measured(span)
+
               # catch thrown exceptions
               span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
 
@@ -96,7 +99,7 @@ module Datadog
               span.finish(finish)
             end
           rescue StandardError => e
-            Datadog::Tracer.log.error(e.message)
+            Datadog.logger.error(e.message)
           end
 
           def endpoint_start_render(*)
@@ -112,7 +115,7 @@ module Datadog
 
             Thread.current[KEY_RENDER] = true
           rescue StandardError => e
-            Datadog::Tracer.log.error(e.message)
+            Datadog.logger.error(e.message)
           end
 
           def endpoint_render(name, start, finish, id, payload)
@@ -126,13 +129,16 @@ module Datadog
 
             # catch thrown exceptions
             begin
+              # Measure service stats
+              Contrib::Analytics.set_measured(span)
+
               span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
             ensure
               span.start_time = start
               span.finish(finish)
             end
           rescue StandardError => e
-            Datadog::Tracer.log.error(e.message)
+            Datadog.logger.error(e.message)
           end
 
           def endpoint_run_filters(name, start, finish, id, payload)
@@ -156,6 +162,9 @@ module Datadog
                 Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
               end
 
+              # Measure service stats
+              Contrib::Analytics.set_measured(span)
+
               # catch thrown exceptions
               span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
               span.set_tag(Ext::TAG_FILTER_TYPE, type.to_s)
@@ -164,7 +173,7 @@ module Datadog
               span.finish(finish)
             end
           rescue StandardError => e
-            Datadog::Tracer.log.error(e.message)
+            Datadog.logger.error(e.message)
           end
 
           private