ddtrace 0.45.0 → 0.50.0

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

@@ -0,0 +1,57 @@
+#--
+# Copyright (c) 2007-2013 Nick Sieger.
+# See the file README.txt included with the distribution for
+# software license details.
+#++
+
+require 'ddtrace/vendor/multipart-post/multipart/post/parts'
+require 'ddtrace/vendor/multipart-post/multipart/post/composite_read_io'
+require 'securerandom'
+
+module Datadog
+  module Vendor
+    module Multipart
+      module Post
+        module Multipartable
+          def self.secure_boundary
+            # https://tools.ietf.org/html/rfc7230
+            #      tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+            #                     / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+            #                     / DIGIT / ALPHA
+
+            # https://tools.ietf.org/html/rfc2046
+            #      bcharsnospace := DIGIT / ALPHA / "'" / "(" / ")" /
+            #                       "+" / "_" / "," / "-" / "." /
+            #                       "/" / ":" / "=" / "?"
+
+            "--#{SecureRandom.uuid}"
+          end
+
+          def initialize(path, params, headers={}, boundary = Multipartable.secure_boundary)
+            headers = headers.clone # don't want to modify the original variable
+            parts_headers = headers.delete(:parts) || {}
+            super(path, headers)
+            parts = params.map do |k,v|
+              case v
+              when Array
+                v.map {|item| Parts::Part.new(boundary, "#{k}[]", item, parts_headers[k]) }
+              else
+                Parts::Part.new(boundary, k, v, parts_headers[k])
+              end
+            end.flatten
+            parts << Parts::EpiloguePart.new(boundary)
+            ios = parts.map {|p| p.to_io }
+            self.set_content_type(headers["Content-Type"] || "multipart/form-data",
+                                  { "boundary" => boundary })
+            self.content_length = parts.inject(0) {|sum,i| sum + i.length }
+            self.body_stream = CompositeReadIO.new(*ios)
+
+            @boundary = boundary
+          end
+
+          attr :boundary
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+#--
+# 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

@@ -0,0 +1,9 @@
+module Datadog
+  module Vendor
+    module Multipart
+      module Post
+        VERSION = "2.1.1"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+#--
+# 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/version.rb

@@ -1,12 +1,24 @@
 module Datadog
   module VERSION
     MAJOR = 0
-    MINOR = 45
+    MINOR = 50
     PATCH = 0
     PRE = nil
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
 
-    MINIMUM_RUBY_VERSION = '2.0.0'.freeze
+    MINIMUM_RUBY_VERSION = '2.1.0'.freeze
+
+    # Ruby 3.2 is not supported: Ruby 3.x support as implemented using *args
+    # needs ruby2_keywords to continue working, yet the scheduled removal of
+    # ruby2_keywords when Ruby 2.6 is EOL'd (i.e on Ruby 3.2 release) would
+    # leave the code with no option, other than to move to *args, **kwargs.
+    #
+    # See https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/
+    #
+    # This constraint can only be removed when the dependency on ruby2_keywords is
+    # dropped. An allowance is nonetheless made to test prerelease versions.
+    # The version constraint may be bumped if the removal is postponed.
+    MAXIMUM_RUBY_VERSION = '3.2'.freeze
   end
 end

data/lib/ddtrace/workers.rb

@@ -67,9 +67,13 @@ module Datadog
       def start
         @mutex.synchronize do
           return if @run
+
           @run = true
-          Datadog.logger.debug("Starting thread in the process: #{Process.pid}")
+          Datadog.logger.debug { "Starting thread for: #{self}" }
           @worker = Thread.new { perform }
+          @worker.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+
+          nil
         end
       end
 
@@ -108,6 +112,7 @@ module Datadog
 
           @mutex.synchronize do
             return if !@run && @trace_buffer.empty?
+
             @shutdown.wait(@mutex, @back_off) if @run # do not wait when shutting down
           end
         end

data/lib/ddtrace/workers/async.rb

@@ -12,13 +12,13 @@ module Datadog
         SHUTDOWN_TIMEOUT = 1
 
         def self.included(base)
-          base.send(:prepend, PrependedMethods)
+          base.prepend(PrependedMethods)
         end
 
         # Methods that must be prepended
         module PrependedMethods
           def perform(*args)
-            start { self.result = super(*args) } unless started?
+            start_async { self.result = super(*args) } unless started?
           end
         end
 
@@ -31,18 +31,22 @@ module Datadog
 
         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
 
@@ -56,6 +60,7 @@ module Datadog
 
         def error?
           return false unless instance_variable_defined?(:@error)
+
           !@error.nil?
         end
 
@@ -101,9 +106,10 @@ module Datadog
           @worker ||= nil
         end
 
-        def start(&block)
+        def start_async(&block)
           mutex.synchronize do
             return if running?
+
             if forked?
               case fork_policy
               when FORK_POLICY_STOP
@@ -121,7 +127,7 @@ module Datadog
           @run_async = true
           @pid = Process.pid
           @error = nil
-          Datadog.logger.debug("Starting thread in the process: #{Process.pid}")
+          Datadog.logger.debug { "Starting thread for: #{self}" }
 
           @worker = ::Thread.new do
             begin
@@ -133,6 +139,9 @@ module Datadog
               raise
             end
           end
+          @worker.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+
+          nil
         end
 
         def stop_fork

data/lib/ddtrace/workers/loop.rb

@@ -8,7 +8,7 @@ module Datadog
       BASE_INTERVAL = 1
 
       def self.included(base)
-        base.send(:prepend, PrependedMethods)
+        base.prepend(PrependedMethods)
       end
 
       # Methods that must be prepended
@@ -21,6 +21,7 @@ module Datadog
       def stop_loop
         mutex.synchronize do
           return false unless run_loop?
+
           @run_loop = false
           shutdown.signal
         end
@@ -34,6 +35,7 @@ module Datadog
 
       def run_loop?
         return false unless instance_variable_defined?(:@run_loop)
+
         @run_loop == true
       end
 
@@ -53,12 +55,29 @@ module Datadog
         @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!(amount = nil)
-        @loop_wait_time = amount || [loop_wait_time * BACK_OFF_RATIO, BACK_OFF_MAX].min
+      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
@@ -75,16 +94,22 @@ module Datadog
       private
 
       def perform_loop
-        @run_loop = true
+        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
-            loop_back_off!(loop_base_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
@@ -92,6 +117,7 @@ module Datadog
           # 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