ddtrace 0.54.1 → 1.0.0.beta2

data/lib/ddtrace/vendor/multipart-post/multipart/post/parts.rb

@@ -1,136 +0,0 @@
-# typed: true
-#--
-# Copyright (c) 2007-2013 Nick Sieger.
-# See the file README.txt included with the distribution for
-# software license details.
-#++
-
-module Datadog
-  module Vendor
-    module Multipart
-      module Post
-        module Parts
-          module Part
-            def self.new(boundary, name, value, headers = {})
-              headers ||= {} # avoid nil values
-              if file?(value)
-                FilePart.new(boundary, name, value, headers)
-              else
-                ParamPart.new(boundary, name, value, headers)
-              end
-            end
-
-            def self.file?(value)
-              value.respond_to?(:content_type) && value.respond_to?(:original_filename)
-            end
-
-            def length
-              @part.length
-            end
-
-            def to_io
-              @io
-            end
-          end
-
-          # Represents a parametric part to be filled with given value.
-          class ParamPart
-            include Part
-
-            # @param boundary [String]
-            # @param name [#to_s]
-            # @param value [String]
-            # @param headers [Hash] Content-Type and Content-ID are used, if present.
-            def initialize(boundary, name, value, headers = {})
-              @part = build_part(boundary, name, value, headers)
-              @io = StringIO.new(@part)
-            end
-
-            def length
-              @part.bytesize
-            end
-
-            # @param boundary [String]
-            # @param name [#to_s]
-            # @param value [String]
-            # @param headers [Hash] Content-Type is used, if present.
-            def build_part(boundary, name, value, headers = {})
-              part = ''
-              part << "--#{boundary}\r\n"
-              part << "Content-ID: #{headers["Content-ID"]}\r\n" if headers["Content-ID"]
-              part << "Content-Disposition: form-data; name=\"#{name.to_s}\"\r\n"
-              part << "Content-Type: #{headers["Content-Type"]}\r\n" if headers["Content-Type"]
-              part << "\r\n"
-              part << "#{value}\r\n"
-            end
-          end
-
-          # Represents a part to be filled from file IO.
-          class FilePart
-            include Part
-
-            attr_reader :length
-
-            # @param boundary [String]
-            # @param name [#to_s]
-            # @param io [IO]
-            # @param headers [Hash]
-            def initialize(boundary, name, io, headers = {})
-              file_length = io.respond_to?(:length) ?  io.length : File.size(io.local_path)
-              @head = build_head(boundary, name, io.original_filename, io.content_type, file_length,
-                                 io.respond_to?(:opts) ? io.opts.merge(headers) : headers)
-              @foot = "\r\n"
-              @length = @head.bytesize + file_length + @foot.length
-              @io = CompositeReadIO.new(StringIO.new(@head), io, StringIO.new(@foot))
-            end
-
-            # @param boundary [String]
-            # @param name [#to_s]
-            # @param filename [String]
-            # @param type [String]
-            # @param content_len [Integer]
-            # @param opts [Hash]
-            def build_head(boundary, name, filename, type, content_len, opts = {})
-              opts = opts.clone
-
-              trans_encoding = opts.delete("Content-Transfer-Encoding") || "binary"
-              content_disposition = opts.delete("Content-Disposition") || "form-data"
-
-              part = ''
-              part << "--#{boundary}\r\n"
-              part << "Content-Disposition: #{content_disposition}; name=\"#{name.to_s}\"; filename=\"#{filename}\"\r\n"
-              part << "Content-Length: #{content_len}\r\n"
-              if content_id = opts.delete("Content-ID")
-                part << "Content-ID: #{content_id}\r\n"
-              end
-
-              if opts["Content-Type"] != nil
-                part <<  "Content-Type: " + opts["Content-Type"] + "\r\n"
-              else
-                part << "Content-Type: #{type}\r\n"
-              end
-
-              part << "Content-Transfer-Encoding: #{trans_encoding}\r\n"
-
-              opts.each do |k, v|
-                part << "#{k}: #{v}\r\n"
-              end
-
-              part << "\r\n"
-            end
-          end
-
-          # Represents the epilogue or closing boundary.
-          class EpiloguePart
-            include Part
-
-            def initialize(boundary)
-              @part = "--#{boundary}--\r\n"
-              @io = StringIO.new(@part)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/vendor/multipart-post/multipart/post/version.rb

@@ -1,10 +0,0 @@
-# typed: strict
-module Datadog
-  module Vendor
-    module Multipart
-      module Post
-        VERSION = "2.1.1"
-      end
-    end
-  end
-end

data/lib/ddtrace/vendor/multipart-post/multipart/post.rb

@@ -1,9 +0,0 @@
-# typed: strict
-module Datadog
-  module Vendor
-    module Multipart
-      module Post
-      end
-    end
-  end
-end

data/lib/ddtrace/vendor/multipart-post/multipart.rb

@@ -1,13 +0,0 @@
-# typed: strict
-#--
-# Copyright (c) 2007-2013 Nick Sieger.
-# See the file README.txt included with the distribution for
-# software license details.
-#++
-
-module Datadog
-  module Vendor
-    module Multipart
-    end
-  end
-end

data/lib/ddtrace/vendor/multipart-post/net/http/post/multipart.rb

@@ -1,33 +0,0 @@
-# typed: strict
-#--
-# Copyright (c) 2007-2012 Nick Sieger.
-# See the file README.txt included with the distribution for
-# software license details.
-#++
-
-require 'net/http'
-require 'stringio'
-require 'cgi'
-require 'ddtrace/vendor/multipart-post/multipart/post/parts'
-require 'ddtrace/vendor/multipart-post/multipart/post/composite_read_io'
-require 'ddtrace/vendor/multipart-post/multipart/post/multipartable'
-
-module Datadog
-  module Vendor
-    module Net
-      class HTTP
-        class Put
-          class Multipart < ::Net::HTTP::Put
-            include ::Datadog::Vendor::Multipart::Post::Multipartable
-          end
-        end
-
-        class Post
-          class Multipart < ::Net::HTTP::Post
-            include ::Datadog::Vendor::Multipart::Post::Multipartable
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/worker.rb

@@ -1,21 +0,0 @@
-# typed: true
-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,175 +0,0 @@
-# typed: false
-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.prepend(PrependedMethods)
-        end
-
-        # Methods that must be prepended
-        module PrependedMethods
-          def perform(*args)
-            start_async { 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
-          Datadog.logger.debug { "Forcibly terminating worker thread for: #{self}" }
-          worker.terminate
-          true
-        end
-
-        def run_async?
-          return 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?
-          return false 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_async(&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
-          Datadog.logger.debug { "Starting thread for: #{self}" }
-
-          @worker = ::Thread.new do
-            begin
-              yield
-            # rubocop:disable Lint/RescueException
-            rescue Exception => e
-              @error = e
-              Datadog.logger.debug("Worker thread error. Cause #{e.message} Location: #{Array(e.backtrace).first}")
-              raise
-            end
-          end
-          @worker.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
-
-          nil
-        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,132 +0,0 @@
-# typed: false
-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.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?
-        return 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_wait_time=(value)
-        @loop_wait_time = value
-      end
-
-      def reset_loop_wait_time
-        self.loop_wait_time = loop_base_interval
-      end
-
-      # Should the loop "back off" when there's no work?
-      def loop_back_off?
-        false
-      end
-
-      def loop_back_off!
-        self.loop_wait_time = [loop_wait_time * BACK_OFF_RATIO, BACK_OFF_MAX].min
-      end
-
-      # Should perform_loop just straight into work, or start by waiting?
-      #
-      # The use case is if we want to report some information (like profiles) from time to time, we may not want to
-      # report empty/zero/some residual value immediately when the worker starts.
-      def loop_wait_before_first_iteration?
-        false
-      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
-        mutex.synchronize do
-          @run_loop = true
-
-          shutdown.wait(mutex, loop_wait_time) if loop_wait_before_first_iteration?
-        end
-
-        loop do
-          if work_pending?
-            # There's work to do...
-            # Run the task
-            yield
-
-            # Reset the wait interval
-            reset_loop_wait_time if loop_back_off?
-          elsif loop_back_off?
-            # There's no work to do...
-            # 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,56 +0,0 @@
-# typed: false
-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.include(Workers::IntervalLoop)
-        base.include(Workers::Async::Thread)
-        base.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 !graceful && force_stop
-            Datadog.logger.debug do
-              "Timeout while waiting for worker to finish gracefully, forcing termination for: #{self}"
-            end
-            terminate
-          else
-            graceful
-          end
-        else
-          false
-        end
-      end
-
-      def enabled?
-        return 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,41 +0,0 @@
-# typed: false
-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.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
-
-      # Are there more items to be processed next?
-      def work_pending?
-        !buffer.empty?
-      end
-
-      protected
-
-      attr_writer \
-        :buffer
-    end
-  end
-end

data/lib/ddtrace/workers/runtime_metrics.rb

@@ -1,65 +0,0 @@
-# typed: false
-require 'forwardable'
-
-require 'ddtrace/runtime/metrics'
-
-require 'ddtrace/worker'
-require 'ddtrace/workers/polling'
-
-module Datadog
-  module Workers
-    # Emits runtime metrics asynchronously on a timed loop
-    class RuntimeMetrics < Worker
-      extend Forwardable
-      include Workers::Polling
-
-      # In seconds
-      DEFAULT_FLUSH_INTERVAL = 10
-      DEFAULT_BACK_OFF_MAX = 30
-
-      attr_reader \
-        :metrics
-
-      def initialize(options = {})
-        @metrics = options.fetch(:metrics) { Runtime::Metrics.new }
-
-        # Workers::Async::Thread settings
-        self.fork_policy = options.fetch(:fork_policy, Workers::Async::Thread::FORK_POLICY_STOP)
-
-        # Workers::IntervalLoop settings
-        self.loop_base_interval = options.fetch(:interval, DEFAULT_FLUSH_INTERVAL)
-        self.loop_back_off_ratio = options[:back_off_ratio] if options.key?(:back_off_ratio)
-        self.loop_back_off_max = options.fetch(:back_off_max, DEFAULT_BACK_OFF_MAX)
-
-        self.enabled = options.fetch(:enabled, false)
-      end
-
-      def perform
-        metrics.flush
-        true
-      end
-
-      def associate_with_span(*args)
-        # Start the worker
-        metrics.associate_with_span(*args).tap { perform }
-      end
-
-      # TODO: `close_metrics` is only needed because
-      # Datadog::Components directly manipulates the lifecycle of
-      # Runtime::Metrics.statsd instances.
-      # This should be avoided, as it prevents this class from
-      # ensuring correct resource decommission of its internal
-      # dependencies.
-      def stop(*args, close_metrics: true)
-        self.enabled = false
-        result = super(*args)
-        @metrics.close if close_metrics
-        result
-      end
-
-      def_delegators \
-        :metrics,
-        :register_service
-    end
-  end
-end