ddtrace 0.13.0 → 0.47.0

data/lib/ddtrace/configurable.rb

@@ -1,83 +0,0 @@
-module Datadog
-  InvalidOptionError = Class.new(StandardError)
-  # Configurable provides configuration methods for a given class/module
-  module Configurable
-    IDENTITY = ->(x) { x }
-
-    def self.included(base)
-      base.singleton_class.send(:include, ClassMethods)
-    end
-
-    # ClassMethods
-    module ClassMethods
-      def set_option(name, value)
-        __assert_valid!(name)
-
-        __options[name][:value] = __options[name][:setter].call(value)
-        __options[name][:set_flag] = true
-      end
-
-      def get_option(name)
-        __assert_valid!(name)
-
-        return __default_value(name) unless __options[name][:set_flag]
-
-        __options[name][:value]
-      end
-
-      def to_h
-        __options.each_with_object({}) do |(key, _), hash|
-          hash[key] = get_option(key)
-        end
-      end
-
-      def reset_options!
-        __options.each do |name, meta|
-          set_option(name, meta[:default])
-        end
-      end
-
-      def sorted_options
-        Configuration::Resolver.new(__dependency_graph).call
-      end
-
-      private
-
-      def option(name, meta = {}, &block)
-        name = name.to_sym
-        meta[:setter] ||= (block || IDENTITY)
-        meta[:depends_on] ||= []
-        meta[:lazy] ||= false
-        __options[name] = meta
-      end
-
-      def __options
-        @__options ||= {}
-      end
-
-      def __assert_valid!(name)
-        return if __options.key?(name)
-        raise(InvalidOptionError, "#{__pretty_name} doesn't have the option: #{name}")
-      end
-
-      def __pretty_name
-        entry = Datadog.registry.find { |el| el.klass == self }
-
-        return entry.name if entry
-
-        to_s
-      end
-
-      def __dependency_graph
-        __options.each_with_object({}) do |(name, meta), graph|
-          graph[name] = meta[:depends_on]
-        end
-      end
-
-      def __default_value(name)
-        return __options[name][:default].call if __options[name][:lazy]
-        __options[name][:default]
-      end
-    end
-  end
-end

data/lib/ddtrace/configuration/proxy.rb

@@ -1,25 +0,0 @@
-require 'forwardable'
-
-module Datadog
-  class Configuration
-    # Proxy provides a hash-like interface for fetching/setting configurations
-    class Proxy
-      extend Forwardable
-
-      def initialize(integration)
-        @integration = integration
-      end
-
-      def [](param)
-        @integration.get_option(param)
-      end
-
-      def []=(param, value)
-        @integration.set_option(param, value)
-      end
-
-      def_delegators :@integration, :to_h, :reset_options!
-      def_delegators :to_h, :to_hash, :merge
-    end
-  end
-end

data/lib/ddtrace/contrib/base.rb

@@ -1,15 +0,0 @@
-require 'ddtrace/registry'
-require 'ddtrace/configurable'
-
-module Datadog
-  module Contrib
-    # Base provides features that are shared across all integrations
-    module Base
-      def self.included(base)
-        base.send(:include, Registry::Registerable)
-        base.send(:include, Configurable)
-        base.send(:include, Patcher)
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/mysql2/client.rb

@@ -1,60 +0,0 @@
-require 'ddtrace/ext/sql'
-require 'ddtrace/ext/app_types'
-
-module Datadog
-  module Contrib
-    module Mysql2
-      # Mysql2::Client patch module
-      module Client
-        module_function
-
-        def included(base)
-          if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0.0')
-            base.class_eval do
-              alias_method :aliased_query, :query
-              remove_method :query
-              include InstanceMethods
-            end
-          else
-            base.send(:prepend, InstanceMethods)
-          end
-        end
-
-        # Mysql2::Client patch 1.9.3 instance methods
-        module InstanceMethodsCompatibility
-          def query(*args)
-            aliased_query(*args)
-          end
-        end
-
-        # Mysql2::Client patch instance methods
-        module InstanceMethods
-          if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0.0')
-            include InstanceMethodsCompatibility
-          end
-
-          def query(sql, options = {})
-            datadog_pin.tracer.trace('mysql2.query') do |span|
-              span.resource = sql
-              span.service = datadog_pin.service
-              span.span_type = Datadog::Ext::SQL::TYPE
-              span.set_tag('mysql2.db.name', query_options[:database])
-              span.set_tag('out.host', query_options[:host])
-              span.set_tag('out.port', query_options[:port])
-              super(sql, options)
-            end
-          end
-
-          def datadog_pin
-            @datadog_pin ||= Datadog::Pin.new(
-              Datadog.configuration[:mysql2][:service_name],
-              app: 'mysql2',
-              app_type: Datadog::Ext::AppTypes::DB,
-              tracer: Datadog.configuration[:mysql2][:tracer]
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-require 'ddtrace/ext/http'
-require 'ddtrace/ext/errors'
-
-module Datadog
-  module Contrib
-    module Rails
-      # Code used to create and handle 'rails.action_controller' spans.
-      module ActionController
-        include Datadog::Patcher
-
-        def self.instrument
-          # patch Rails core components
-          do_once(:instrument) do
-            Datadog::RailsActionPatcher.patch_action_controller
-          end
-        end
-
-        def self.start_processing(payload)
-          # trace the execution
-          tracer = Datadog.configuration[:rails][:tracer]
-          service = Datadog.configuration[:rails][:controller_service]
-          type = Datadog::Ext::HTTP::TYPE
-          span = tracer.trace('rails.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 self.finish_processing(payload)
-          # retrieve the tracing context and the latest active span
-          tracing_context = payload.fetch(:tracing_context)
-          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 parent resource if it's a `rack.request` span,
-            # but not if its an exception contoller.
-            if !span.parent.nil? && span.parent.name == 'rack.request' && !exception_controller?(payload)
-              span.parent.resource = span.resource
-            end
-
-            span.set_tag('rails.route.action', payload.fetch(:action))
-            span.set_tag('rails.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 self.exception_controller?(payload)
-          exception_controller_class = Datadog.configuration[:rails][: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
-      end
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-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

@@ -1,19 +0,0 @@
-require 'ddtrace/contrib/rails/utils'
-
-module Datadog
-  module Contrib
-    module Rails
-      # Code used to create and handle 'rails.render_template' and 'rails.render_partial' spans.
-      module ActionView
-        include Datadog::Patcher
-
-        def self.instrument
-          # patch Rails core components
-          do_once(:instrument) do
-            Datadog::RailsRendererPatcher.patch_renderer
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-require 'thread'
-require 'ddtrace/ext/cache'
-
-module Datadog
-  module Contrib
-    module Rails
-      # Code used to create and handle 'rails.cache' spans.
-      module ActiveSupport
-        include Datadog::Patcher
-
-        def self.instrument
-          do_once(:instrument) do
-            # patch Rails core components
-            Datadog::RailsCachePatcher.patch_cache_store
-          end
-        end
-
-        def self.start_trace_cache(payload)
-          tracer = Datadog.configuration[:rails][:tracer]
-
-          # 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
-          # interesting details.
-          # 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 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'.freeze, service: service, span_type: type)
-          span.resource = payload.fetch(:action)
-          tracing_context[:dd_cache_span] = span
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
-
-        def self.finish_trace_cache(payload)
-          # retrieve the tracing context and continue the trace
-          tracing_context = payload.fetch(:tracing_context)
-          span = tracing_context[:dd_cache_span]
-          return unless span && !span.finished?
-
-          begin
-            # discard parameters from the cache_store configuration
-            store, = *Array.wrap(::Rails.configuration.cache_store).flatten
-            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'.freeze, cache_key)
-            span.set_error(payload[:exception]) if payload[:exception]
-          ensure
-            span.finish
-          end
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
-      end
-    end
-  end
-end