ddtrace 0.35.2 → 1.1.0

data/lib/datadog/core/vendor/multipart-post/multipart/post/parts.rb

@@ -0,0 +1,139 @@
+# typed: true
+
+#--
+# Copyright (c) 2007-2013 Nick Sieger.
+# See the file README.txt included with the distribution for
+# software license details.
+#++
+
+module Datadog
+  module Core
+    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
+end

data/lib/datadog/core/vendor/multipart-post/multipart/post/version.rb

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

data/lib/datadog/core/vendor/multipart-post/multipart/post.rb

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

data/lib/datadog/core/vendor/multipart-post/multipart.rb

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

data/lib/datadog/core/vendor/multipart-post/net/http/post/multipart.rb

@@ -0,0 +1,36 @@
+# 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 'datadog/core/vendor/multipart-post/multipart/post/parts'
+require 'datadog/core/vendor/multipart-post/multipart/post/composite_read_io'
+require 'datadog/core/vendor/multipart-post/multipart/post/multipartable'
+
+module Datadog
+  module Core
+    module Vendor
+      module Net
+        class HTTP
+          class Put
+            class Multipart < ::Net::HTTP::Put
+              include Vendor::Multipart::Post::Multipartable
+            end
+          end
+
+          class Post
+            class Multipart < ::Net::HTTP::Post
+              include Vendor::Multipart::Post::Multipartable
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/worker.rb

@@ -0,0 +1,24 @@
+# typed: true
+
+module Datadog
+  module Core
+    # 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
+end

data/lib/datadog/core/workers/async.rb

@@ -0,0 +1,182 @@
+# typed: false
+
+require 'datadog/core/logger'
+
+module Datadog
+  module Core
+    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.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+                )
+                raise
+              end
+              # rubocop:enable Lint/RescueException
+            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
+        # rubocop:enable Metrics/ModuleLength
+      end
+    end
+  end
+end

data/lib/datadog/core/workers/interval_loop.rb

@@ -0,0 +1,119 @@
+# typed: false
+
+module Datadog
+  module Core
+    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 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
+            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
+end

data/lib/datadog/core/workers/polling.rb

@@ -0,0 +1,59 @@
+# typed: false
+
+require 'datadog/core/workers/async'
+require 'datadog/core/workers/interval_loop'
+
+module Datadog
+  module Core
+    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
+end

data/lib/datadog/core/workers/queue.rb

@@ -0,0 +1,44 @@
+# typed: false
+
+module Datadog
+  module Core
+    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
+end