ddtrace 0.34.1 → 1.23.1

data/lib/ddtrace/vendor/active_record/connection_specification.rb

@@ -1,301 +0,0 @@
-require 'uri'
-
-# NOTE: This code is copied directly from ActiveRecord.
-#       Its purpose is to resolve connection information.
-#       It exists here only because it doesn't exist in Rails 3.2.
-#       When support for Rails 3.2 is dropped, this can be removed.
-module Datadog
-  module Vendor
-    module ActiveRecord
-      # Copy/paste from:
-      # https://github.com/rails/rails/blob/5-2-stable/activerecord/lib/active_record/connection_handling.rb
-      module ConnectionHandling
-        RAILS_ENV = -> { (Rails.env if defined?(Rails) && defined?(Rails.env)) || ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence }
-      end
-
-      # Copy/paste from:
-      # https://github.com/rails/rails/blob/5-2-stable/activerecord/lib/active_record/connection_adapters/connection_specification.rb
-      module ConnectionAdapters
-        class ConnectionSpecification
-          attr_reader :name, :config, :adapter_method
-
-          def initialize(name, config, adapter_method)
-            @name, @config, @adapter_method = name, config, adapter_method
-          end
-
-          def initialize_dup(original)
-            @config = original.config.dup
-          end
-
-          def to_hash
-            @config.merge(name: @name)
-          end
-
-          # Expands a connection string into a hash.
-          class ConnectionUrlResolver # :nodoc:
-            # == Example
-            #
-            #   url = "postgresql://foo:bar@localhost:9000/foo_test?pool=5&timeout=3000"
-            #   ConnectionUrlResolver.new(url).to_hash
-            #   # => {
-            #     "adapter"  => "postgresql",
-            #     "host"     => "localhost",
-            #     "port"     => 9000,
-            #     "database" => "foo_test",
-            #     "username" => "foo",
-            #     "password" => "bar",
-            #     "pool"     => "5",
-            #     "timeout"  => "3000"
-            #   }
-            def initialize(url)
-              raise "Database URL cannot be empty" if url.blank?
-              @uri     = uri_parser.parse(url)
-              @adapter = @uri.scheme && @uri.scheme.tr("-", "_")
-              @adapter = "postgresql" if @adapter == "postgres"
-
-              if @uri.opaque
-                @uri.opaque, @query = @uri.opaque.split("?", 2)
-              else
-                @query = @uri.query
-              end
-            end
-
-            # Converts the given URL to a full connection hash.
-            def to_hash
-              config = raw_config.reject { |_, value| value.blank? }
-              config.map { |key, value| config[key] = uri_parser.unescape(value) if value.is_a? String }
-              config
-            end
-
-            private
-
-              def uri
-                @uri
-              end
-
-              def uri_parser
-                @uri_parser ||= URI::Parser.new
-              end
-
-              # Converts the query parameters of the URI into a hash.
-              #
-              #   "localhost?pool=5&reaping_frequency=2"
-              #   # => { "pool" => "5", "reaping_frequency" => "2" }
-              #
-              # returns empty hash if no query present.
-              #
-              #   "localhost"
-              #   # => {}
-              def query_hash
-                Hash[(@query || "").split("&").map { |pair| pair.split("=") }]
-              end
-
-              def raw_config
-                if uri.opaque
-                  query_hash.merge(
-                    "adapter"  => @adapter,
-                    "database" => uri.opaque)
-                else
-                  query_hash.merge(
-                    "adapter"  => @adapter,
-                    "username" => uri.user,
-                    "password" => uri.password,
-                    "port"     => uri.port,
-                    "database" => database_from_path,
-                    "host"     => uri.hostname)
-                end
-              end
-
-              # Returns name of the database.
-              def database_from_path
-                if @adapter == "sqlite3"
-                  # 'sqlite3:/foo' is absolute, because that makes sense. The
-                  # corresponding relative version, 'sqlite3:foo', is handled
-                  # elsewhere, as an "opaque".
-
-                  uri.path
-                else
-                  # Only SQLite uses a filename as the "database" name; for
-                  # anything else, a leading slash would be silly.
-
-                  uri.path.sub(%r{^/}, "")
-                end
-              end
-          end
-
-          ##
-          # Builds a ConnectionSpecification from user input.
-          class Resolver # :nodoc:
-            attr_reader :configurations
-
-            # Accepts a hash two layers deep, keys on the first layer represent
-            # environments such as "production". Keys must be strings.
-            def initialize(configurations)
-              @configurations = configurations
-            end
-
-            # Returns a hash with database connection information.
-            #
-            # == Examples
-            #
-            # Full hash Configuration.
-            #
-            #   configurations = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
-            #   Resolver.new(configurations).resolve(:production)
-            #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3"}
-            #
-            # Initialized with URL configuration strings.
-            #
-            #   configurations = { "production" => "postgresql://localhost/foo" }
-            #   Resolver.new(configurations).resolve(:production)
-            #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-            #
-            def resolve(config)
-              if config
-                resolve_connection config
-              elsif env = ConnectionHandling::RAILS_ENV.call
-                resolve_symbol_connection env.to_sym
-              else
-                raise AdapterNotSpecified
-              end
-            end
-
-            # Expands each key in @configurations hash into fully resolved hash
-            def resolve_all
-              config = configurations.dup
-
-              if env = ConnectionHandling::DEFAULT_ENV.call
-                env_config = config[env] if config[env].is_a?(Hash) && !(config[env].key?("adapter") || config[env].key?("url"))
-              end
-
-              config.reject! { |k, v| v.is_a?(Hash) && !(v.key?("adapter") || v.key?("url")) }
-              config.merge! env_config if env_config
-
-              config.each do |key, value|
-                config[key] = resolve(value) if value
-              end
-
-              config
-            end
-
-            # Returns an instance of ConnectionSpecification for a given adapter.
-            # Accepts a hash one layer deep that contains all connection information.
-            #
-            # == Example
-            #
-            #   config = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
-            #   spec = Resolver.new(config).spec(:production)
-            #   spec.adapter_method
-            #   # => "sqlite3_connection"
-            #   spec.config
-            #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" }
-            #
-            def spec(config)
-              spec = resolve(config).symbolize_keys
-
-              raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
-
-              # Require the adapter itself and give useful feedback about
-              #   1. Missing adapter gems and
-              #   2. Adapter gems' missing dependencies.
-              path_to_adapter = "active_record/connection_adapters/#{spec[:adapter]}_adapter"
-              begin
-                require path_to_adapter
-              rescue LoadError => e
-                # We couldn't require the adapter itself. Raise an exception that
-                # points out config typos and missing gems.
-                if e.path == path_to_adapter
-                  # We can assume that a non-builtin adapter was specified, so it's
-                  # either misspelled or missing from Gemfile.
-                  raise e.class, "Could not load the '#{spec[:adapter]}' Active Record adapter. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile.", e.backtrace
-
-                # Bubbled up from the adapter require. Prefix the exception message
-                # with some guidance about how to address it and reraise.
-                else
-                  raise e.class, "Error loading the '#{spec[:adapter]}' Active Record adapter. Missing a gem it depends on? #{e.message}", e.backtrace
-                end
-              end
-
-              adapter_method = "#{spec[:adapter]}_connection"
-
-              unless ::ActiveRecord::Base.respond_to?(adapter_method)
-                raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
-              end
-
-              ConnectionSpecification.new(spec.delete(:name) || "primary", spec, adapter_method)
-            end
-
-            private
-
-              # Returns fully resolved connection, accepts hash, string or symbol.
-              # Always returns a hash.
-              #
-              # == Examples
-              #
-              # Symbol representing current environment.
-              #
-              #   Resolver.new("production" => {}).resolve_connection(:production)
-              #   # => {}
-              #
-              # One layer deep hash of connection values.
-              #
-              #   Resolver.new({}).resolve_connection("adapter" => "sqlite3")
-              #   # => { "adapter" => "sqlite3" }
-              #
-              # Connection URL.
-              #
-              #   Resolver.new({}).resolve_connection("postgresql://localhost/foo")
-              #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-              #
-              def resolve_connection(spec)
-                case spec
-                when Symbol
-                  resolve_symbol_connection spec
-                when String
-                  resolve_url_connection spec
-                when Hash
-                  resolve_hash_connection spec
-                end
-              end
-
-              # Takes the environment such as +:production+ or +:development+.
-              # This requires that the @configurations was initialized with a key that
-              # matches.
-              #
-              #   Resolver.new("production" => {}).resolve_symbol_connection(:production)
-              #   # => {}
-              #
-              def resolve_symbol_connection(spec)
-                if config = configurations[spec.to_s]
-                  resolve_connection(config).merge("name" => spec.to_s)
-                else
-                  raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available: #{configurations.keys.inspect}")
-                end
-              end
-
-              # Accepts a hash. Expands the "url" key that contains a
-              # URL database connection to a full connection
-              # hash and merges with the rest of the hash.
-              # Connection details inside of the "url" key win any merge conflicts
-              def resolve_hash_connection(spec)
-                if spec["url"] && spec["url"] !~ /^jdbc:/
-                  connection_hash = resolve_url_connection(spec.delete("url"))
-                  spec.merge!(connection_hash)
-                end
-                spec
-              end
-
-              # Takes a connection URL.
-              #
-              #   Resolver.new({}).resolve_url_connection("postgresql://localhost/foo")
-              #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-              #
-              def resolve_url_connection(url)
-                ConnectionUrlResolver.new(url).to_hash
-              end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/worker.rb

@@ -1,20 +0,0 @@
-module Datadog
-  # Base class for work tasks
-  class Worker
-    attr_reader \
-      :task
-
-    def initialize(&block)
-      @task = block
-    end
-
-    def perform(*args)
-      task.call(*args) unless task.nil?
-    end
-
-    protected
-
-    attr_writer \
-      :task
-  end
-end

data/lib/ddtrace/workers/async.rb

@@ -1,165 +0,0 @@
-require 'ddtrace/logger'
-
-module Datadog
-  module Workers
-    module Async
-      # Adds threading behavior to workers
-      # to run tasks asynchronously.
-      # rubocop:disable Metrics/ModuleLength
-      module Thread
-        FORK_POLICY_STOP = :stop
-        FORK_POLICY_RESTART = :restart
-        SHUTDOWN_TIMEOUT = 1
-
-        def self.included(base)
-          base.send(:prepend, PrependedMethods)
-        end
-
-        # Methods that must be prepended
-        module PrependedMethods
-          def perform(*args)
-            start { self.result = super(*args) } unless started?
-          end
-        end
-
-        attr_reader \
-          :error,
-          :result
-
-        attr_writer \
-          :fork_policy
-
-        def join(timeout = nil)
-          return true unless running?
-          !worker.join(timeout).nil?
-        end
-
-        def terminate
-          return false unless running?
-          @run_async = false
-          worker.terminate
-          true
-        end
-
-        def run_async?
-          @run_async = false unless instance_variable_defined?(:@run_async)
-          @run_async == true
-        end
-
-        def started?
-          !(worker.nil? || forked?)
-        end
-
-        def running?
-          !worker.nil? && worker.alive?
-        end
-
-        def error?
-          @error = nil unless instance_variable_defined?(:@error)
-          !@error.nil?
-        end
-
-        def completed?
-          !worker.nil? && worker.status == false && !error?
-        end
-
-        def failed?
-          !worker.nil? && worker.status.nil?
-        end
-
-        def forked?
-          !pid.nil? && pid != Process.pid
-        end
-
-        def fork_policy
-          @fork_policy ||= FORK_POLICY_STOP
-        end
-
-        protected
-
-        attr_writer \
-          :result
-
-        def mutex
-          @mutex ||= Mutex.new
-        end
-
-        def after_fork
-          # Do nothing by default
-        end
-
-        private
-
-        attr_reader \
-          :pid
-
-        def mutex_after_fork
-          @mutex_after_fork ||= Mutex.new
-        end
-
-        def worker
-          @worker ||= nil
-        end
-
-        def start(&block)
-          mutex.synchronize do
-            return if running?
-            if forked?
-              case fork_policy
-              when FORK_POLICY_STOP
-                stop_fork
-              when FORK_POLICY_RESTART
-                restart_after_fork(&block)
-              end
-            elsif !run_async?
-              start_worker(&block)
-            end
-          end
-        end
-
-        def start_worker
-          @run_async = true
-          @pid = Process.pid
-          @error = nil
-          Logger.log.debug("Starting thread in the process: #{Process.pid}")
-
-          @worker = ::Thread.new do
-            begin
-              yield
-            # rubocop:disable Lint/RescueException
-            rescue Exception => e
-              @error = e
-              Logger.log.debug("Worker thread error. Cause #{e.message} Location: #{e.backtrace.first}")
-              raise
-            end
-          end
-        end
-
-        def stop_fork
-          mutex_after_fork.synchronize do
-            if forked?
-              # Trigger callback to allow workers to reset themselves accordingly
-              after_fork
-
-              # Reset and turn off
-              @pid = Process.pid
-              @run_async = false
-            end
-          end
-        end
-
-        def restart_after_fork(&block)
-          mutex_after_fork.synchronize do
-            if forked?
-              # Trigger callback to allow workers to reset themselves accordingly
-              after_fork
-
-              # Start worker
-              start_worker(&block)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/workers/loop.rb

@@ -1,105 +0,0 @@
-module Datadog
-  module Workers
-    # Adds looping behavior to workers, with a sleep
-    # interval between each loop.
-    module IntervalLoop
-      BACK_OFF_RATIO = 1.2
-      BACK_OFF_MAX = 5
-      BASE_INTERVAL = 1
-
-      def self.included(base)
-        base.send(:prepend, PrependedMethods)
-      end
-
-      # Methods that must be prepended
-      module PrependedMethods
-        def perform(*args)
-          perform_loop { super(*args) }
-        end
-      end
-
-      def stop_loop
-        mutex.synchronize do
-          return false unless run_loop?
-          @run_loop = false
-          shutdown.signal
-        end
-
-        true
-      end
-
-      def work_pending?
-        run_loop?
-      end
-
-      def run_loop?
-        @run_loop = false unless instance_variable_defined?(:@run_loop)
-        @run_loop == true
-      end
-
-      def loop_base_interval
-        @loop_base_interval ||= BASE_INTERVAL
-      end
-
-      def loop_back_off_ratio
-        @loop_back_off_ratio ||= BACK_OFF_RATIO
-      end
-
-      def loop_back_off_max
-        @loop_back_off_max ||= BACK_OFF_MAX
-      end
-
-      def loop_wait_time
-        @loop_wait_time ||= loop_base_interval
-      end
-
-      def loop_back_off?
-        false
-      end
-
-      def loop_back_off!(amount = nil)
-        @loop_wait_time = amount || [loop_wait_time * BACK_OFF_RATIO, BACK_OFF_MAX].min
-      end
-
-      protected
-
-      attr_writer \
-        :loop_back_off_max,
-        :loop_back_off_ratio,
-        :loop_base_interval
-
-      def mutex
-        @mutex ||= Mutex.new
-      end
-
-      private
-
-      def perform_loop
-        @run_loop = true
-
-        loop do
-          if work_pending?
-            # Run the task
-            yield
-
-            # Reset the wait interval
-            loop_back_off!(loop_base_interval)
-          elsif loop_back_off?
-            # Back off the wait interval a bit
-            loop_back_off!
-          end
-
-          # Wait for an interval, unless shutdown has been signaled.
-          mutex.synchronize do
-            return unless run_loop? || work_pending?
-            shutdown.wait(mutex, loop_wait_time) if run_loop?
-          end
-        end
-      end
-
-      def shutdown
-        @shutdown ||= ConditionVariable.new
-      end
-    end
-  end
-end

data/lib/ddtrace/workers/polling.rb

@@ -1,48 +0,0 @@
-require 'ddtrace/workers/async'
-require 'ddtrace/workers/loop'
-
-module Datadog
-  module Workers
-    # Adds polling (async looping) behavior to workers
-    module Polling
-      SHUTDOWN_TIMEOUT = 1
-
-      def self.included(base)
-        base.send(:include, Workers::IntervalLoop)
-        base.send(:include, Workers::Async::Thread)
-        base.send(:prepend, PrependedMethods)
-      end
-
-      # Methods that must be prepended
-      module PrependedMethods
-        def perform(*args)
-          super if enabled?
-        end
-      end
-
-      def stop(force_stop = false, timeout = SHUTDOWN_TIMEOUT)
-        if running?
-          # Attempt graceful stop and wait
-          stop_loop
-          graceful = join(timeout)
-
-          # If timeout and force stop...
-          !graceful && force_stop ? terminate : graceful
-        else
-          false
-        end
-      end
-
-      def enabled?
-        @enabled = true unless instance_variable_defined?(:@enabled)
-        @enabled
-      end
-
-      # Allow worker to be started
-      def enabled=(value)
-        # Coerce to boolean
-        @enabled = (value == true)
-      end
-    end
-  end
-end

data/lib/ddtrace/workers/queue.rb

@@ -1,39 +0,0 @@
-module Datadog
-  module Workers
-    # Adds queue behavior to workers, with a buffer
-    # to which items can be queued then dequeued.
-    module Queue
-      def self.included(base)
-        base.send(:prepend, PrependedMethods)
-      end
-
-      # Methods that must be prepended
-      module PrependedMethods
-        def perform(*args)
-          super(*dequeue) if work_pending?
-        end
-      end
-
-      def buffer
-        @buffer ||= []
-      end
-
-      def enqueue(*args)
-        buffer.push(args)
-      end
-
-      def dequeue
-        buffer.shift
-      end
-
-      def work_pending?
-        !buffer.empty?
-      end
-
-      protected
-
-      attr_writer \
-        :buffer
-    end
-  end
-end