ddtrace 0.44.0 → 0.48.0

data/lib/ddtrace/augmentation.rb

@@ -1,13 +0,0 @@
-require 'ddtrace/augmentation/method_wrapper'
-require 'ddtrace/augmentation/method_wrapping'
-require 'ddtrace/augmentation/shim'
-
-module Datadog
-  # Namespace for components that help modify
-  # existing code for instrumentation purposes.
-  module Augmentation
-    def shim(object, &block)
-      Shim.new(object, &block)
-    end
-  end
-end

data/lib/ddtrace/augmentation/method_wrapper.rb

@@ -1,20 +0,0 @@
-module Datadog
-  # Represents an wrapped method, with a reference to the original block
-  # and the block that wraps around it.
-  class MethodWrapper
-    attr_reader \
-      :original,
-      :wrapper
-
-    DEFAULT_WRAPPER = proc { |original, *args, &block| original.call(*args, &block) }
-
-    def initialize(original, &block)
-      @original = original
-      @wrapper = block_given? ? block : DEFAULT_WRAPPER
-    end
-
-    def call(*args, &block)
-      wrapper.call(original, *args, &block)
-    end
-  end
-end

data/lib/ddtrace/augmentation/method_wrapping.rb

@@ -1,38 +0,0 @@
-require 'set'
-require 'ddtrace/patcher'
-
-module Datadog
-  # Shorthands for wrapping methods
-  module MethodWrapping
-    include Datadog::Patcher
-
-    def wrapped_methods
-      @wrapped_methods ||= Set.new
-    end
-
-    # Adds method block directly to the object.
-    # Block is evaluated in the context of the object.
-    # Faster than #wrap_method!
-    def override_method!(method_name, &block)
-      return unless block_given?
-
-      without_warnings do
-        define_singleton_method(method_name, &block).tap do
-          wrapped_methods.add(method_name)
-        end
-      end
-    end
-
-    # Adds method wrapper to the object.
-    # Block is evaluated in the original context of the block.
-    # Slower than #override_method!
-    def wrap_method!(original_method, &block)
-      return unless block_given?
-      original_method = original_method.is_a?(Symbol) ? method(original_method) : original_method
-
-      override_method!(original_method.name) do |*original_args, &original_block|
-        block.call(original_method, *original_args, &original_block)
-      end
-    end
-  end
-end

data/lib/ddtrace/augmentation/shim.rb

@@ -1,102 +0,0 @@
-require 'set'
-require 'ddtrace/patcher'
-require 'ddtrace/augmentation/method_wrapping'
-
-module Datadog
-  # A "stand-in" that intercepts calls to another object. i.e. man-in-the-middle.
-  # This shim forwards all methods to object, except those overriden.
-  # Useful if you want to intercept inbound behavior to an object without modifying
-  # the object in question, especially useful if the overridding behavior shouldn't be global.
-  class Shim
-    extend Forwardable
-    include Datadog::Patcher
-    include Datadog::MethodWrapping
-
-    METHODS = Set[
-      :override_method!,
-      :shim,
-      :shim?,
-      :shim_target,
-      :wrap_method!,
-      :wrapped_methods
-    ].freeze
-
-    EXCLUDED_METHODS = Set[
-      # For all objects
-      :__binding__,
-      :__id__,
-      :__send__,
-      :extend,
-      :itself,
-      :object_id,
-      :respond_to?,
-      :tap
-    ].freeze
-
-    attr_reader :shim_target, :shim
-
-    def self.shim?(object)
-      # Check whether it responds to #shim? because otherwise the
-      # Shim forwards all method calls, including type checks to
-      # the wrapped object, to mimimize its intrusion.
-      object.respond_to?(:shim?)
-    end
-
-    # Pass this a block to override methods
-    def initialize(shim_target)
-      @shim = self
-      @shim_target = shim_target
-
-      # Save a reference to the original :define_singleton_method
-      # so methods can be defined on the shim after forwarding is applied.
-      @definition_method = method(:define_singleton_method)
-
-      # Wrap any methods
-      yield(self) if block_given?
-
-      # Forward methods
-      forwarded_methods = (
-        shim_target.public_methods.to_set \
-        - METHODS \
-        - EXCLUDED_METHODS \
-        - wrapped_methods
-      )
-      forward_methods!(*forwarded_methods)
-    end
-
-    def override_method!(method_name, &block)
-      return unless block_given?
-
-      without_warnings do
-        @definition_method.call(method_name, &block).tap do
-          wrapped_methods.add(method_name)
-        end
-      end
-    end
-
-    def wrap_method!(method_name, &block)
-      super(shim_target.method(method_name), &block)
-    end
-
-    def shim?
-      true
-    end
-
-    def respond_to?(method_name)
-      return true if METHODS.include?(method_name)
-      shim_target.respond_to?(method_name)
-    end
-
-    private
-
-    def forward_methods!(*forwarded_methods)
-      return if forwarded_methods.empty?
-
-      singleton_class.send(
-        :def_delegators,
-        :@shim_target,
-        *forwarded_methods
-      )
-    end
-  end
-end

data/lib/ddtrace/contrib/rspec/example_group.rb

@@ -1,61 +0,0 @@
-module Datadog
-  module Contrib
-    module RSpec
-      # Instrument RSpec::Core::ExampleGroup
-      module ExampleGroup
-        def self.included(base)
-          base.singleton_class.send(:prepend, ClassMethods)
-        end
-
-        # Class methods for configuration
-        module ClassMethods
-          def run(reporter = ::RSpec::Core::NullReporter)
-            configuration = Datadog.configuration[:rspec]
-            return super unless configuration[:enabled]
-
-            trace_options = {
-              app: Ext::APP,
-              resource: description,
-              service: configuration[:service_name],
-              span_type: Datadog::Ext::AppTypes::TEST,
-              tags: tags.merge(Datadog.configuration.tags)
-            }
-
-            configuration[:tracer].trace(Ext::EXAMPLE_GROUP_OPERATION_NAME, trace_options) do |span|
-              span.set_tag(Datadog::Ext::Test::TAG_FRAMEWORK, Ext::FRAMEWORK)
-              span.set_tag(Datadog::Ext::Test::TAG_NAME, description)
-              span.set_tag(Datadog::Ext::Test::TAG_SUITE, file_path)
-              span.set_tag(Datadog::Ext::Test::TAG_TYPE, Ext::TEST_TYPE)
-              span.set_tag(Datadog::Ext::Test::TAG_SPAN_KIND, Datadog::Ext::AppTypes::TEST)
-
-              # Set analytics sample rate
-              if Datadog::Contrib::Analytics.enabled?(configuration[:analytics_enabled])
-                Datadog::Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
-              end
-
-              # Measure service stats
-              Contrib::Analytics.set_measured(span)
-
-              result = super
-
-              if ::RSpec.world.wants_to_quit
-                span.status = 1
-                span.set_tag(Datadog::Ext::Test::TAG_STATUS, Datadog::Ext::Test::Status::FAIL)
-              else
-                span.set_tag(Datadog::Ext::Test::TAG_STATUS, Datadog::Ext::Test::Status::PASS)
-              end
-
-              result
-            end
-          end
-
-          private
-
-          def tags
-            @tags ||= Datadog::Ext::CI.tags(ENV)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/monkey.rb

@@ -1,58 +0,0 @@
-module Datadog
-  # TODO: Remove me!
-  # Monkey was used for monkey-patching 3rd party libs.
-  # It is now DEPRECATED. This API is no-op, and serves only to warn
-  # of its deactivation.
-  module Monkey
-    @registry = Datadog.registry
-
-    DEPRECATION_WARNING = %(
-      Datadog::Monkey has been REMOVED as of version 0.11.1.
-      All calls to Datadog::Monkey are no-ops.
-      *Implementations using Monkey will no longer function*.
-      Upgrade to the new configuration API using the migration guide here:
-      https://github.com/DataDog/dd-trace-rb/releases/tag/v0.11.0).freeze
-
-    module_function
-
-    def registry
-      log_deprecation_warning('Monkey#registry')
-      @registry
-    end
-
-    def autopatch_modules
-      log_deprecation_warning('Monkey#autopatch_modules')
-      {}
-    end
-
-    def patch_all
-      log_deprecation_warning('Monkey#patch_all')
-    end
-
-    def patch_module(m)
-      log_deprecation_warning('Monkey#patch_module')
-    end
-
-    def patch(modules)
-      log_deprecation_warning('Monkey#patch')
-    end
-
-    def get_patched_modules
-      log_deprecation_warning('Monkey#get_patched_modules')
-      {}
-    end
-
-    def without_warnings(&block)
-      log_deprecation_warning('Monkey#without_warnings')
-      Datadog::Patcher.without_warnings(&block)
-    end
-
-    def log_deprecation_warning(method)
-      Datadog.logger.warn("#{method}:#{DEPRECATION_WARNING}")
-    end
-
-    class << self
-      attr_writer :registry
-    end
-  end
-end