ls-trace 0.1.1

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

@@ -0,0 +1,34 @@
+require 'ddtrace/contrib/patcher'
+
+module Datadog
+  module Contrib
+    module Excon
+      # Patcher enables patching of 'excon' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:excon)
+        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
+        end
+
+        def add_middleware
+          ::Excon.defaults[:middlewares] = Middleware.around_default_stack
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/extensions.rb

@@ -0,0 +1,59 @@
+require 'ddtrace/contrib/registry'
+
+module Datadog
+  module Contrib
+    # Extensions that can be added to the base library
+    # Adds registry, configuration access for integrations.
+    module Extensions
+      def self.extended(base)
+        Datadog.send(:extend, Helpers)
+        Datadog::Configuration::Settings.send(:include, Configuration::Settings)
+      end
+
+      # Helper methods for Datadog module.
+      module Helpers
+        def registry
+          configuration.registry
+        end
+      end
+
+      module Configuration
+        # Extensions for Datadog::Configuration::Settings
+        module Settings
+          InvalidIntegrationError = Class.new(StandardError)
+
+          def self.included(base)
+            # Add the additional options to the global configuration settings
+            base.instance_eval do
+              option :registry, default: Registry.new
+            end
+          end
+
+          def [](integration_name, configuration_name = :default)
+            integration = fetch_integration(integration_name)
+            integration.configuration(configuration_name) unless integration.nil?
+          end
+
+          def use(integration_name, options = {}, &block)
+            integration = fetch_integration(integration_name)
+
+            unless integration.nil?
+              configuration_name = options[:describes] || :default
+              filtered_options = options.reject { |k, _v| k == :describes }
+              integration.configure(configuration_name, filtered_options, &block)
+            end
+
+            integration.patch if integration.respond_to?(:patch)
+          end
+
+          private
+
+          def fetch_integration(name)
+            get_option(:registry)[name] ||
+              raise(InvalidIntegrationError, "'#{name}' is not a valid integration.")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/ext/http'
+require 'ddtrace/contrib/faraday/ext'
+
+module Datadog
+  module Contrib
+    module Faraday
+      module Configuration
+        # Custom settings for the Faraday integration
+        class Settings < Contrib::Configuration::Settings
+          DEFAULT_ERROR_HANDLER = lambda do |env|
+            Datadog::Ext::HTTP::ERROR_RANGE.cover?(env[:status])
+          end
+
+          option :analytics_enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.lazy
+          end
+
+          option :distributed_tracing, default: true
+          option :error_handler, default: DEFAULT_ERROR_HANDLER
+          option :service_name, default: Ext::SERVICE_NAME
+          option :split_by_domain, default: false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Datadog
+  module Contrib
+    module Faraday
+      # 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
+        SERVICE_NAME = 'faraday'.freeze
+        SPAN_REQUEST = 'faraday.request'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/faraday/configuration/settings'
+require 'ddtrace/contrib/faraday/patcher'
+
+module Datadog
+  module Contrib
+    module Faraday
+      # Description of Faraday integration
+      class Integration
+        include Contrib::Integration
+
+        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)
+        end
+
+        def self.compatible?
+          super && version < Gem::Version.new('1.0.0')
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+require 'faraday'
+require 'ddtrace/ext/http'
+require 'ddtrace/ext/net'
+require 'ddtrace/propagation/http_propagator'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/faraday/ext'
+
+module Datadog
+  module Contrib
+    module Faraday
+      # Middleware implements a faraday-middleware for ddtrace instrumentation
+      class Middleware < ::Faraday::Middleware
+        include Datadog::Ext::DistributedTracing
+
+        def initialize(app, options = {})
+          super(app)
+          @options = datadog_configuration.options_hash.merge(options)
+          setup_service!
+        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) }
+          end
+        end
+
+        private
+
+        attr_reader :app, :options
+
+        def annotate!(span, env)
+          span.resource = resource_name(env)
+          span.service = service_name(env)
+          span.span_type = Datadog::Ext::HTTP::TYPE_OUTBOUND
+
+          # Set analytics sample rate
+          if analytics_enabled?
+            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
+          end
+
+          span.set_tag(Datadog::Ext::HTTP::URL, env[:url].path)
+          span.set_tag(Datadog::Ext::HTTP::METHOD, env[:method].to_s.upcase)
+          span.set_tag(Datadog::Ext::NET::TARGET_HOST, env[:url].host)
+          span.set_tag(Datadog::Ext::NET::TARGET_PORT, env[:url].port)
+        end
+
+        def handle_response(span, env)
+          if options.fetch(:error_handler).call(env)
+            span.set_error(["Error #{env[:status]}", env[:body]])
+          end
+
+          span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, env[:status])
+        end
+
+        def propagate!(span, env)
+          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]
+        end
+
+        def setup_service!
+          return if options[:service_name] == datadog_configuration[:service_name]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/faraday/ext'
+require 'ddtrace/contrib/faraday/rack_builder'
+
+module Datadog
+  module Contrib
+    module Faraday
+      # Patcher enables patching of 'faraday' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:faraday)
+        end
+
+        def patch
+          do_once(:faraday) do
+            begin
+              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
+        end
+
+        def add_pin!
+          DeprecatedPin
+            .new(
+              get_option(:service_name),
+              app: Ext::APP,
+              app_type: Datadog::Ext::AppTypes::WEB,
+              tracer: get_option(:tracer)
+            ).onto(::Faraday)
+        end
+
+        def register_middleware!
+          ::Faraday::Middleware.register_middleware(ddtrace: Middleware)
+        end
+
+        def add_default_middleware!
+          ::Faraday::RackBuilder.send(:prepend, RackBuilder)
+        end
+
+        def get_option(option)
+          Datadog.configuration[:faraday].get_option(option)
+        end
+
+        # Implementation of deprecated Pin, which raises warnings when accessed.
+        # To be removed when support for Datadog::Pin with Faraday is removed.
+        class DeprecatedPin < Datadog::Pin
+          include Datadog::DeprecatedPin
+
+          DEPRECATION_WARNING = %(
+            Use of Datadog::Pin with Faraday is DEPRECATED.
+            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}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Datadog
+  module Contrib
+    module Faraday
+      # Handles installation of our middleware if the user has *not*
+      # already explicitly configured it for this correction.
+      #
+      # RackBuilder class was introduced in faraday 0.9.0:
+      # https://github.com/lostisland/faraday/commit/77d7546d6d626b91086f427c56bc2cdd951353b3
+      module RackBuilder
+        def adapter(*args)
+          use(:ddtrace) unless @handlers.any? { |h| h.klass == Middleware }
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/ext/http'
+require 'ddtrace/contrib/grape/ext'
+
+module Datadog
+  module Contrib
+    module Grape
+      module Configuration
+        # Custom settings for the Grape integration
+        class Settings < Contrib::Configuration::Settings
+          option :analytics_enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, nil) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.lazy
+          end
+
+          option :enabled, default: true
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+require 'ddtrace/ext/http'
+require 'ddtrace/ext/errors'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/rack/ext'
+
+module Datadog
+  module Contrib
+    module Grape
+      # rubocop:disable Metrics/ModuleLength
+      # Endpoint module includes a list of subscribers to create
+      # traces when a Grape endpoint is hit
+      module Endpoint
+        KEY_RUN = 'datadog_grape_endpoint_run'.freeze
+        KEY_RENDER = 'datadog_grape_endpoint_render'.freeze
+
+        class << self
+          def subscribe
+            # subscribe when a Grape endpoint is hit
+            ::ActiveSupport::Notifications.subscribe('endpoint_run.grape.start_process') do |*args|
+              endpoint_start_process(*args)
+            end
+            ::ActiveSupport::Notifications.subscribe('endpoint_run.grape') do |*args|
+              endpoint_run(*args)
+            end
+            ::ActiveSupport::Notifications.subscribe('endpoint_render.grape.start_render') do |*args|
+              endpoint_start_render(*args)
+            end
+            ::ActiveSupport::Notifications.subscribe('endpoint_render.grape') do |*args|
+              endpoint_render(*args)
+            end
+            ::ActiveSupport::Notifications.subscribe('endpoint_run_filters.grape') do |*args|
+              endpoint_run_filters(*args)
+            end
+          end
+
+          def endpoint_start_process(*)
+            return if Thread.current[KEY_RUN]
+            return unless enabled?
+
+            # Store the beginning of a trace
+            tracer.trace(
+              Ext::SPAN_ENDPOINT_RUN,
+              service: service_name,
+              span_type: Datadog::Ext::HTTP::TYPE_INBOUND
+            )
+
+            Thread.current[KEY_RUN] = true
+          rescue StandardError => e
+            Datadog::Tracer.log.error(e.message)
+          end
+
+          def endpoint_run(name, start, finish, id, payload)
+            return unless Thread.current[KEY_RUN]
+            Thread.current[KEY_RUN] = false
+
+            return unless enabled?
+
+            span = tracer.active_span
+            return unless span
+
+            begin
+              # collect endpoint details
+              api = payload[:endpoint].options[:for]
+              # If the API inherits from Grape::API in version >= 1.2.0
+              # then the API will be an instance and the name must be derived from the base.
+              # See https://github.com/ruby-grape/grape/issues/1825
+              api_view = if defined?(::Grape::API::Instance) && api <= ::Grape::API::Instance
+                           api.base.to_s
+                         else
+                           api.to_s
+                         end
+
+              path = payload[:endpoint].options[:path].join('/')
+              resource = "#{api_view}##{path}"
+              span.resource = resource
+
+              # set the request span resource if it's a `rack.request` span
+              request_span = payload[:env][Datadog::Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN]
+              if !request_span.nil? && request_span.name == Datadog::Contrib::Rack::Ext::SPAN_REQUEST
+                request_span.resource = resource
+              end
+
+              # Set analytics sample rate
+              if analytics_enabled?
+                Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
+              end
+
+              # catch thrown exceptions
+              span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
+
+              # override the current span with this notification values
+              span.set_tag(Ext::TAG_ROUTE_ENDPOINT, api_view) unless api_view.nil?
+              span.set_tag(Ext::TAG_ROUTE_PATH, path)
+            ensure
+              span.start_time = start
+              span.finish(finish)
+            end
+          rescue StandardError => e
+            Datadog::Tracer.log.error(e.message)
+          end
+
+          def endpoint_start_render(*)
+            return if Thread.current[KEY_RENDER]
+            return unless enabled?
+
+            # Store the beginning of a trace
+            tracer.trace(
+              Ext::SPAN_ENDPOINT_RENDER,
+              service: service_name,
+              span_type: Datadog::Ext::HTTP::TEMPLATE
+            )
+
+            Thread.current[KEY_RENDER] = true
+          rescue StandardError => e
+            Datadog::Tracer.log.error(e.message)
+          end
+
+          def endpoint_render(name, start, finish, id, payload)
+            return unless Thread.current[KEY_RENDER]
+            Thread.current[KEY_RENDER] = false
+
+            return unless enabled?
+
+            span = tracer.active_span
+            return unless span
+
+            # catch thrown exceptions
+            begin
+              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)
+          end
+
+          def endpoint_run_filters(name, start, finish, id, payload)
+            return unless enabled?
+
+            # safe-guard to prevent submitting empty filters
+            zero_length = (finish - start).zero?
+            filters = payload[:filters]
+            type = payload[:type]
+            return if (!filters || filters.empty?) || !type || zero_length
+
+            span = tracer.trace(
+              Ext::SPAN_ENDPOINT_RUN_FILTERS,
+              service: service_name,
+              span_type: Datadog::Ext::HTTP::TYPE_INBOUND
+            )
+
+            begin
+              # Set analytics sample rate
+              if analytics_enabled?
+                Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
+              end
+
+              # catch thrown exceptions
+              span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
+              span.set_tag(Ext::TAG_FILTER_TYPE, type.to_s)
+            ensure
+              span.start_time = start
+              span.finish(finish)
+            end
+          rescue StandardError => e
+            Datadog::Tracer.log.error(e.message)
+          end
+
+          private
+
+          def tracer
+            datadog_configuration[:tracer]
+          end
+
+          def service_name
+            datadog_configuration[:service_name]
+          end
+
+          def analytics_enabled?
+            Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+          end
+
+          def analytics_sample_rate
+            datadog_configuration[:analytics_sample_rate]
+          end
+
+          def enabled?
+            datadog_configuration[:enabled] == true
+          end
+
+          def datadog_configuration
+            Datadog.configuration[:grape]
+          end
+        end
+      end
+    end
+  end
+end