ddtrace 0.54.2 → 1.0.0.beta1

data/lib/ddtrace/configuration/dependency_resolver.rb

@@ -1,25 +0,0 @@
-# typed: false
-require 'tsort'
-
-module Datadog
-  module Configuration
-    # Resolver performs a topological sort over the dependency graph
-    class DependencyResolver
-      include TSort
-
-      def initialize(dependency_graph = {})
-        @dependency_graph = dependency_graph
-      end
-
-      def tsort_each_node(&blk)
-        @dependency_graph.each_key(&blk)
-      end
-
-      def tsort_each_child(node, &blk)
-        @dependency_graph.fetch(node).each(&blk)
-      end
-
-      alias call tsort
-    end
-  end
-end

data/lib/ddtrace/configuration/option.rb

@@ -1,65 +0,0 @@
-# typed: true
-module Datadog
-  module Configuration
-    # Represents an instance of an integration configuration option
-    class Option
-      attr_reader \
-        :definition
-
-      def initialize(definition, context)
-        @definition = definition
-        @context = context
-        @value = nil
-        @is_set = false
-      end
-
-      def set(value)
-        old_value = @value
-        (@value = context_exec(value, old_value, &definition.setter)).tap do |v|
-          @is_set = true
-          context_exec(v, old_value, &definition.on_set) if definition.on_set
-        end
-      end
-
-      def get
-        if @is_set
-          @value
-        elsif definition.delegate_to
-          context_eval(&definition.delegate_to)
-        else
-          set(default_value)
-        end
-      end
-
-      def reset
-        @value = if definition.resetter
-                   # Don't change @is_set to false; custom resetters are
-                   # responsible for changing @value back to a good state.
-                   # Setting @is_set = false would cause a default to be applied.
-                   context_exec(@value, &definition.resetter)
-                 else
-                   @is_set = false
-                   nil
-                 end
-      end
-
-      def default_value
-        if definition.lazy
-          context_eval(&definition.default)
-        else
-          definition.default
-        end
-      end
-
-      private
-
-      def context_exec(*args, &block)
-        @context.instance_exec(*args, &block)
-      end
-
-      def context_eval(&block)
-        @context.instance_eval(&block)
-      end
-    end
-  end
-end

data/lib/ddtrace/configuration/option_definition.rb

@@ -1,122 +0,0 @@
-# typed: true
-require 'ddtrace/configuration/option'
-
-module Datadog
-  module Configuration
-    # Represents a definition for an integration configuration option
-    class OptionDefinition
-      IDENTITY = ->(new_value, _old_value) { new_value }
-
-      attr_reader \
-        :default,
-        :delegate_to,
-        :depends_on,
-        :lazy,
-        :name,
-        :on_set,
-        :resetter,
-        :setter
-
-      def initialize(name, meta = {}, &block)
-        @default = meta[:default]
-        @delegate_to = meta[:delegate_to]
-        @depends_on = meta[:depends_on] || []
-        @lazy = meta[:lazy] || false
-        @name = name.to_sym
-        @on_set = meta[:on_set]
-        @resetter = meta[:resetter]
-        @setter = meta[:setter] || block || IDENTITY
-      end
-
-      # Creates a new Option, bound to the context provided.
-      def build(context)
-        Option.new(self, context)
-      end
-
-      # Acts as DSL for building OptionDefinitions
-      class Builder
-        attr_reader \
-          :helpers
-
-        def initialize(name, options = {})
-          @default = nil
-          @delegate_to = nil
-          @depends_on = []
-          @helpers = {}
-          @lazy = false
-          @name = name.to_sym
-          @on_set = nil
-          @resetter = nil
-          @setter = OptionDefinition::IDENTITY
-
-          # If options were supplied, apply them.
-          apply_options!(options)
-
-          # Apply block if given.
-          yield(self) if block_given?
-        end
-
-        def depends_on(*values)
-          @depends_on = values.flatten
-        end
-
-        def default(value = nil, &block)
-          @default = block || value
-        end
-
-        def delegate_to(&block)
-          @delegate_to = block
-        end
-
-        def helper(name, *_args, &block)
-          @helpers[name] = block
-        end
-
-        def lazy(value = true)
-          @lazy = value
-        end
-
-        def on_set(&block)
-          @on_set = block
-        end
-
-        def resetter(&block)
-          @resetter = block
-        end
-
-        def setter(&block)
-          @setter = block
-        end
-
-        # For applying options for OptionDefinition
-        def apply_options!(options = {})
-          return if options.nil? || options.empty?
-
-          default(options[:default]) if options.key?(:default)
-          delegate_to(&options[:delegate_to]) if options.key?(:delegate_to)
-          depends_on(*options[:depends_on]) if options.key?(:depends_on)
-          lazy(options[:lazy]) if options.key?(:lazy)
-          on_set(&options[:on_set]) if options.key?(:on_set)
-          resetter(&options[:resetter]) if options.key?(:resetter)
-          setter(&options[:setter]) if options.key?(:setter)
-        end
-
-        def to_definition
-          OptionDefinition.new(@name, meta)
-        end
-
-        def meta
-          {
-            default: @default,
-            delegate_to: @delegate_to,
-            depends_on: @depends_on,
-            lazy: @lazy,
-            on_set: @on_set,
-            resetter: @resetter,
-            setter: @setter
-          }
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/configuration/option_definition_set.rb

@@ -1,19 +0,0 @@
-# typed: true
-require 'ddtrace/configuration/dependency_resolver'
-
-module Datadog
-  module Configuration
-    # Represents a set of configuration option definitions for an integration
-    class OptionDefinitionSet < Hash
-      def dependency_order
-        DependencyResolver.new(dependency_graph).call
-      end
-
-      def dependency_graph
-        each_with_object({}) do |(name, option), graph|
-          graph[name] = option.depends_on
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/configuration/option_set.rb

@@ -1,7 +0,0 @@
-# typed: true
-module Datadog
-  module Configuration
-    class OptionSet < Hash
-    end
-  end
-end

data/lib/ddtrace/configuration/options.rb

@@ -1,112 +0,0 @@
-# typed: false
-require 'ddtrace/configuration/option_set'
-require 'ddtrace/configuration/option_definition'
-require 'ddtrace/configuration/option_definition_set'
-
-module Datadog
-  module Configuration
-    # Behavior for a configuration object that has options
-    module Options
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.include(InstanceMethods)
-      end
-
-      # Class behavior for a configuration object with options
-      module ClassMethods
-        def options
-          # Allows for class inheritance of option definitions
-          @options ||= superclass <= Options ? superclass.options.dup : OptionDefinitionSet.new
-        end
-
-        protected
-
-        def option(name, meta = {}, &block)
-          builder = OptionDefinition::Builder.new(name, meta, &block)
-          options[name] = builder.to_definition.tap do
-            # Resolve and define helper functions
-            helpers = default_helpers(name)
-            # Prevent unnecessary creation of an identical copy of helpers if there's nothing to merge
-            helpers = helpers.merge(builder.helpers) unless builder.helpers.empty?
-            define_helpers(helpers)
-          end
-        end
-
-        private
-
-        def default_helpers(name)
-          option_name = name.to_sym
-
-          {
-            option_name.to_sym => proc do
-              get_option(option_name)
-            end,
-            "#{option_name}=".to_sym => proc do |value|
-              set_option(option_name, value)
-            end
-          }
-        end
-
-        def define_helpers(helpers)
-          helpers.each do |name, block|
-            next unless block.is_a?(Proc)
-
-            define_method(name, &block)
-          end
-        end
-      end
-
-      # Instance behavior for a configuration object with options
-      module InstanceMethods
-        def options
-          @options ||= OptionSet.new
-        end
-
-        def set_option(name, value)
-          add_option(name) unless options.key?(name)
-          options[name].set(value)
-        end
-
-        def get_option(name)
-          add_option(name) unless options.key?(name)
-          options[name].get
-        end
-
-        def reset_option(name)
-          assert_valid_option!(name)
-          options[name].reset if options.key?(name)
-        end
-
-        def option_defined?(name)
-          self.class.options.key?(name)
-        end
-
-        def options_hash
-          self.class.options.merge(options).each_with_object({}) do |(key, _), hash|
-            hash[key] = get_option(key)
-          end
-        end
-
-        def reset_options!
-          options.values.each(&:reset)
-        end
-
-        private
-
-        def add_option(name)
-          assert_valid_option!(name)
-          definition = self.class.options[name]
-          definition.build(self).tap do |option|
-            options[name] = option
-          end
-        end
-
-        def assert_valid_option!(name)
-          raise(InvalidOptionError, "#{self.class.name} doesn't define the option: #{name}") unless option_defined?(name)
-        end
-      end
-
-      InvalidOptionError = Class.new(StandardError)
-    end
-  end
-end

data/lib/ddtrace/configuration/pin_setup.rb

@@ -1,32 +0,0 @@
-# typed: true
-module Datadog
-  module Configuration
-    # PinSetup translates a flat hash into a Pin configuration
-    # This class should be removed if we ever remove/refactor the Pin class
-    class PinSetup
-      def initialize(target, opts = {})
-        @pin = Pin.get_from(target)
-        @opts = opts
-      end
-
-      def call
-        return unless pin
-
-        ATTRS.each { |key| pin.public_send("#{key}=", opts[key]) if opts[key] }
-
-        pin.config = opts.reject { |key, _| ATTRS.include?(key) || DEPRECATED_ATTRS.include?(key) }
-
-        true
-      end
-
-      private
-
-      attr_reader :pin, :opts
-
-      ATTRS = [:app, :tags, :app_type, :name, :service_name].freeze
-      DEPRECATED_ATTRS = [:tracer].freeze
-
-      private_constant :ATTRS
-    end
-  end
-end