ddtrace 0.50.0 → 1.0.0

data/lib/ddtrace/contrib/active_support/notifications/event.rb

@@ -1,75 +0,0 @@
-require 'ddtrace/contrib/active_support/notifications/subscriber'
-
-module Datadog
-  module Contrib
-    module ActiveSupport
-      module Notifications
-        # Defines behaviors for an ActiveSupport::Notifications event.
-        # Compose this into a module or class, then define
-        # #event_name, #span_name, and #process. You can then
-        # invoke Event.subscribe! to more easily subscribe to an event.
-        module Event
-          def self.included(base)
-            base.include(Subscriber)
-            base.extend(ClassMethods)
-            base.send(:on_subscribe) { base.subscribe }
-          end
-
-          # Redefines some class behaviors for a Subscriber to make
-          # it a bit simpler for an Event.
-          module ClassMethods
-            DEFAULT_TRACER = -> { Datadog.tracer }
-
-            # Publicly exposes protected method `subscribe!`
-            def subscribe! # rubocop:disable Lint/UselessMethodDefinition
-              super
-            end
-
-            def subscription(span_name = nil, options = nil, tracer = nil)
-              super(
-                span_name || self.span_name,
-                options || span_options,
-                tracer || self.tracer,
-                &method(:process)
-              )
-            end
-
-            def subscribe(pattern = nil, span_name = nil, options = nil, tracer = nil)
-              if supported?
-                super(
-                  pattern || event_name,
-                  span_name || self.span_name,
-                  options || span_options,
-                  tracer || self.tracer,
-                  &method(:process)
-                )
-              end
-            end
-
-            def supported?
-              true
-            end
-
-            def span_options
-              {}
-            end
-
-            def tracer
-              DEFAULT_TRACER
-            end
-
-            def report_if_exception(span, payload)
-              exception = payload_exception(payload)
-              span.set_error(payload[:exception]) if exception
-            end
-
-            def payload_exception(payload)
-              payload[:exception_object] ||
-                payload[:exception] # Fallback for ActiveSupport < 5.0
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/active_support/notifications/subscriber.rb

@@ -1,67 +0,0 @@
-require 'set'
-require 'ddtrace/contrib/active_support/notifications/subscription'
-
-module Datadog
-  module Contrib
-    module ActiveSupport
-      module Notifications
-        # For classes that listen to ActiveSupport::Notification events.
-        # Creates subscriptions that are wrapped with tracing.
-        module Subscriber
-          def self.included(base)
-            base.extend(ClassMethods)
-          end
-
-          # Class methods that are implemented in the inheriting class.
-          module ClassMethods
-            # Returns a list of subscriptions created for this class.
-            def subscriptions
-              @subscriptions ||= Set.new
-            end
-
-            # Returns whether subscriptions have been activated, via #subscribe!
-            def subscribed?
-              subscribed == true
-            end
-
-            protected
-
-            # Defines a callback for when subscribe! is called.
-            # Should contain subscription setup, defined by the inheriting class.
-            def on_subscribe(&block)
-              @on_subscribe_block = block
-            end
-
-            # Runs the on_subscribe callback once, to activate subscriptions.
-            # Should be triggered by the inheriting class.
-            def subscribe!
-              return subscribed? if subscribed? || on_subscribe_block.nil?
-
-              on_subscribe_block.call
-              @subscribed = true
-            end
-
-            # Creates a subscription and immediately activates it.
-            def subscribe(pattern, span_name, options = {}, tracer = -> { Datadog.tracer }, &block)
-              subscription(span_name, options, tracer, &block).tap do |subscription|
-                subscription.subscribe(pattern)
-              end
-            end
-
-            # Creates a subscription without activating it.
-            # Subscription is added to the inheriting class' list of subscriptions.
-            def subscription(span_name, options = {}, tracer = -> { Datadog.tracer }, &block)
-              Subscription.new(tracer, span_name, options, &block).tap do |subscription|
-                subscriptions << subscription
-              end
-            end
-
-            private
-
-            attr_reader :subscribed, :on_subscribe_block
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/active_support/notifications/subscription.rb

@@ -1,163 +0,0 @@
-module Datadog
-  module Contrib
-    module ActiveSupport
-      module Notifications
-        # An ActiveSupport::Notification subscription that wraps events with tracing.
-        class Subscription
-          attr_accessor \
-            :span_name,
-            :options
-
-          def initialize(tracer, span_name, options, &block)
-            raise ArgumentError, 'Must be given a block!' unless block
-
-            @tracer = tracer
-            @span_name = span_name
-            @options = options
-            @handler = Handler.new(&block)
-            @callbacks = Callbacks.new
-          end
-
-          def tracer
-            @tracer.is_a?(Proc) ? @tracer.call : @tracer
-          end
-
-          # ActiveSupport 3.x calls this
-          def call(name, start, finish, id, payload)
-            start_span(name, id, payload, start)
-            finish_span(name, id, payload, finish)
-          end
-
-          # ActiveSupport 4+ calls this on start
-          def start(name, id, payload)
-            start_span(name, id, payload)
-          end
-
-          # ActiveSupport 4+ calls this on finish
-          def finish(name, id, payload)
-            finish_span(name, id, payload)
-          end
-
-          def before_trace(&block)
-            callbacks.add(:before_trace, &block) if block
-          end
-
-          def after_trace(&block)
-            callbacks.add(:after_trace, &block) if block
-          end
-
-          def subscribe(pattern)
-            return false if subscribers.key?(pattern)
-
-            subscribers[pattern] = ::ActiveSupport::Notifications.subscribe(pattern, self)
-            true
-          end
-
-          def unsubscribe(pattern)
-            return false unless subscribers.key?(pattern)
-
-            ::ActiveSupport::Notifications.unsubscribe(subscribers[pattern])
-            subscribers.delete(pattern)
-            true
-          end
-
-          def unsubscribe_all
-            return false if subscribers.empty?
-
-            subscribers.each_key { |pattern| unsubscribe(pattern) }
-            true
-          end
-
-          protected
-
-          attr_reader \
-            :handler,
-            :callbacks
-
-          def start_span(name, id, payload, start = nil)
-            # Run callbacks
-            callbacks.run(name, :before_trace, id, payload, start)
-
-            # Start a trace
-            tracer.trace(@span_name, @options.dup).tap do |span|
-              # Start span if time is provided
-              span.start(start) unless start.nil?
-              payload[:datadog_span] = span
-            end
-          end
-
-          def finish_span(name, id, payload, finish = nil)
-            payload[:datadog_span].tap do |span|
-              # If no active span, return.
-              return nil if span.nil?
-
-              # Run handler for event
-              handler.run(span, name, id, payload)
-
-              # Finish the span
-              span.finish(finish)
-
-              # Run callbacks
-              callbacks.run(name, :after_trace, span, id, payload, finish)
-            end
-          end
-
-          # Pattern => ActiveSupport:Notifications::Subscribers
-          def subscribers
-            @subscribers ||= {}
-          end
-
-          # Wrapper for subscription handler
-          class Handler
-            attr_reader :block
-
-            def initialize(&block)
-              @block = block
-            end
-
-            def run(span, name, id, payload)
-              run!(span, name, id, payload)
-            rescue StandardError => e
-              Datadog.logger.debug("ActiveSupport::Notifications handler for '#{name}' failed: #{e.message}")
-            end
-
-            def run!(*args)
-              @block.call(*args)
-            end
-          end
-
-          # Wrapper for subscription callbacks
-          class Callbacks
-            attr_reader :blocks
-
-            def initialize
-              @blocks = {}
-            end
-
-            def add(key, &block)
-              blocks_for(key) << block if block
-            end
-
-            def run(event, key, *args)
-              blocks_for(key).each do |callback|
-                begin
-                  callback.call(event, key, *args)
-                rescue StandardError => e
-                  Datadog.logger.debug(
-                    "ActiveSupport::Notifications '#{key}' callback for '#{event}' failed: #{e.message}"
-                  )
-                end
-              end
-            end
-
-            private
-
-            def blocks_for(key)
-              blocks[key] ||= []
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/contrib/active_support/cache/patcher'
-
-module Datadog
-  module Contrib
-    module ActiveSupport
-      # Patcher enables patching of 'active_support' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          Cache::Patcher.patch
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/analytics.rb

@@ -1,24 +0,0 @@
-require 'ddtrace/analytics'
-
-module Datadog
-  module Contrib
-    # Defines analytics behavior for integrations
-    module Analytics
-      module_function
-
-      # Checks whether analytics should be enabled.
-      # `flag` is a truthy/falsey value that represents a setting on the integration.
-      def enabled?(flag = nil)
-        (Datadog.configuration.analytics.enabled && flag != false) || flag == true
-      end
-
-      def set_sample_rate(span, sample_rate)
-        Datadog::Analytics.set_sample_rate(span, sample_rate)
-      end
-
-      def set_measured(span, value = true)
-        Datadog::Analytics.set_measured(span, value)
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/auto_instrument.rb

@@ -1,48 +0,0 @@
-require 'ddtrace'
-
-module Datadog
-  module Contrib
-    # Extensions for auto instrumentation added to the base library
-    # AutoInstrumentation enables all integration
-    module AutoInstrument
-      def self.extended(base)
-        base.extend(Patch)
-      end
-
-      # Patch adds method for invoking auto_instrumentation
-      module Patch
-        def add_auto_instrument
-          super
-
-          if Datadog::Contrib::Rails::Utils.railtie_supported?
-            require 'ddtrace/contrib/rails/auto_instrument_railtie'
-          else
-            AutoInstrument.patch_all
-          end
-        end
-      end
-
-      def self.patch_all
-        integrations = []
-
-        Datadog.registry.each do |integration|
-          # some instrumentations are automatically enabled when the `rails` instrumentation is enabled,
-          # patching them on their own automatically outside of the rails integration context would
-          # cause undesirable service naming, so we exclude them based their auto_instrument? setting.
-          # we also don't want to mix rspec/cucumber integration in as rspec is env we run tests in.
-          next unless integration.klass.auto_instrument?
-
-          integrations << integration.name
-        end
-
-        Datadog.configure do |c|
-          c.reduce_log_verbosity
-          # This will activate auto-instrumentation for Rails
-          integrations.each do |integration_name|
-            c.use integration_name
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/aws/ext'
-
-module Datadog
-  module Contrib
-    module Aws
-      module Configuration
-        # Custom settings for the AWS 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, 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, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
-            o.lazy
-          end
-
-          option :service_name, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-module Datadog
-  module Contrib
-    module Aws
-      # AWS integration constants
-      module Ext
-        APP = 'aws'.freeze
-        ENV_ENABLED = 'DD_TRACE_AWS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_AWS_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_AWS_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_AWS_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_AWS_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'aws'.freeze
-        SPAN_COMMAND = 'aws.command'.freeze
-        TAG_AGENT = 'aws.agent'.freeze
-        TAG_DEFAULT_AGENT = 'aws-sdk-ruby'.freeze
-        TAG_HOST = 'host'.freeze
-        TAG_OPERATION = 'aws.operation'.freeze
-        TAG_PATH = 'path'.freeze
-        TAG_REGION = 'aws.region'.freeze
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/aws/instrumentation.rb

@@ -1,90 +0,0 @@
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/aws/ext'
-require 'ddtrace/ext/http'
-require 'ddtrace/ext/integration'
-
-module Datadog
-  module Contrib
-    module Aws
-      # A Seahorse::Client::Plugin that enables instrumentation for all AWS services
-      class Instrumentation < Seahorse::Client::Plugin
-        def add_handlers(handlers, _)
-          handlers.add(Handler, step: :validate)
-        end
-      end
-
-      # Generates Spans for all interactions with AWS
-      class Handler < Seahorse::Client::Handler
-        def call(context)
-          tracer.trace(Ext::SPAN_COMMAND) do |span|
-            @handler.call(context).tap do
-              annotate!(span, ParsedContext.new(context))
-            end
-          end
-        end
-
-        private
-
-        def annotate!(span, context)
-          span.service = configuration[:service_name]
-          span.span_type = Datadog::Ext::HTTP::TYPE_OUTBOUND
-          span.name = Ext::SPAN_COMMAND
-          span.resource = context.safely(:resource)
-
-          # Tag as an external peer service
-          span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
-
-          # Set analytics sample rate
-          if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
-            Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
-          end
-
-          span.set_tag(Ext::TAG_AGENT, Ext::TAG_DEFAULT_AGENT)
-          span.set_tag(Ext::TAG_OPERATION, context.safely(:operation))
-          span.set_tag(Ext::TAG_REGION, context.safely(:region))
-          span.set_tag(Ext::TAG_PATH, context.safely(:path))
-          span.set_tag(Ext::TAG_HOST, context.safely(:host))
-          span.set_tag(Datadog::Ext::HTTP::METHOD, context.safely(:http_method))
-          span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, context.safely(:status_code))
-        end
-
-        def tracer
-          configuration[:tracer]
-        end
-
-        def configuration
-          Datadog.configuration[:aws]
-        end
-      end
-
-      # Removes API request instrumentation from S3 Presign URL creation.
-      #
-      # This is necessary because the S3 SDK invokes the same handler
-      # stack for presigning as it does for sending a real requests.
-      # But presigning does not perform a network request.
-      # There's not information available for our Handler plugin to differentiate
-      # these two types of requests.
-      #
-      # DEV: Since aws-sdk-s3 1.94.1, we only need to check if
-      # `context[:presigned_url] == true` in Datadog::Contrib::Aws::Handler#call
-      # and skip the request if that condition is true. Since there's
-      # no strong reason for us not to support older versions of `aws-sdk-s3`,
-      # this {S3Presigner} monkey-patching is still required.
-      module S3Presigner
-        # Exclude our Handler from the current request's handler stack.
-        #
-        # This is the same approach that the AWS SDK takes to prevent
-        # some of its plugins form interfering with the presigning process:
-        # https://github.com/aws/aws-sdk-ruby/blob/a82c8981c95a8296ffb6269c3c06a4f551d87f7d/gems/aws-sdk-s3/lib/aws-sdk-s3/presigner.rb#L194-L196
-        def sign_but_dont_send(*args, &block)
-          if (request = args[0]).is_a?(::Seahorse::Client::Request)
-            request.handlers.remove(Handler)
-          end
-
-          super(*args, &block)
-        end
-        ruby2_keywords :sign_but_dont_send if respond_to?(:ruby2_keywords, true)
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/aws/configuration/settings'
-require 'ddtrace/contrib/aws/patcher'
-
-module Datadog
-  module Contrib
-    module Aws
-      # Description of AWS integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('2.0')
-
-        register_as :aws, auto_patch: true
-
-        def self.version
-          if Gem.loaded_specs['aws-sdk']
-            Gem.loaded_specs['aws-sdk'].version
-          elsif Gem.loaded_specs['aws-sdk-core']
-            Gem.loaded_specs['aws-sdk-core'].version
-          end
-        end
-
-        def self.loaded?
-          !defined?(::Seahorse::Client::Base).nil?
-        end
-
-        def self.compatible?
-          super && version >= MINIMUM_VERSION
-        end
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/aws/parsed_context.rb

@@ -1,56 +0,0 @@
-module Datadog
-  module Contrib
-    module Aws
-      # A wrapper around Seahorse::Client::RequestContext
-      class ParsedContext
-        def initialize(context)
-          @context = context
-        end
-
-        def safely(attr, fallback = nil)
-          public_send(attr) rescue fallback
-        end
-
-        def resource
-          "#{service}.#{operation}"
-        end
-
-        def operation
-          context.operation_name
-        end
-
-        def status_code
-          context.http_response.status_code
-        end
-
-        def http_method
-          context.http_request.http_method
-        end
-
-        def region
-          context.client.config.region
-        end
-
-        def retry_attempts
-          context.retries
-        end
-
-        def path
-          context.http_request.endpoint.path
-        end
-
-        def host
-          context.http_request.endpoint.host
-        end
-
-        private
-
-        attr_reader :context
-
-        def service
-          context.client.class.to_s.split('::')[1].downcase
-        end
-      end
-    end
-  end
-end