ddtrace 0.42.0 → 0.47.0

data/lib/ddtrace/transport/http/adapters/registry.rb

@@ -15,6 +15,7 @@ module Datadog
           def set(klass, name = nil)
             name ||= klass.to_s
             return if name.nil?
+
             @adapters[name] = klass
           end
         end

data/lib/ddtrace/transport/http/adapters/unix_socket.rb

@@ -18,7 +18,7 @@ module Datadog
             @timeout = options.fetch(:timeout, DEFAULT_TIMEOUT)
           end
 
-          def open
+          def open(&block)
             # Open connection
             connection = HTTP.new(
               filepath,
@@ -26,9 +26,7 @@ module Datadog
               continue_timeout: timeout
             )
 
-            connection.start do |http|
-              yield(http)
-            end
+            connection.start(&block)
           end
 
           def url

data/lib/ddtrace/transport/http/builder.rb

@@ -36,6 +36,7 @@ module Datadog
           @default_adapter = if type.is_a?(Symbol)
                                registry_klass = REGISTRY.get(type)
                                raise UnknownAdapterError, type if registry_klass.nil?
+
                                registry_klass.new(*args)
                              else
                                type
@@ -67,6 +68,7 @@ module Datadog
 
         def default_api=(key)
           raise UnknownApiError, key unless @apis.key?(key)
+
           @default_api = key
         end
 
@@ -93,7 +95,7 @@ module Datadog
               api_options[:headers] = @default_headers.merge((api_options[:headers] || {}))
 
               # Add API::Instance with all settings
-              instances[key] = API::Instance.new(
+              instances[key] = api_instance_class.new(
                 spec,
                 adapter,
                 api_options
@@ -105,6 +107,10 @@ module Datadog
           end
         end
 
+        def api_instance_class
+          API::Instance
+        end
+
         # Raised when the API key does not match known APIs.
         class UnknownApiError < StandardError
           attr_reader :key

data/lib/ddtrace/transport/http/env.rb

@@ -42,6 +42,14 @@ module Datadog
         def headers=(value)
           self[:headers] = value
         end
+
+        def form
+          self[:form] ||= {}
+        end
+
+        def form=(value)
+          self[:form] = value
+        end
       end
     end
   end

data/lib/ddtrace/transport/http/traces.rb

@@ -41,6 +41,7 @@ module Datadog
 
             def send_traces(env, &block)
               raise NoTraceEndpointDefinedError, self if traces.nil?
+
               traces.call(env, &block)
             end
 
@@ -121,9 +122,7 @@ module Datadog
                 # Parse service rates, if configured to do so.
                 if service_rates? && !http_response.payload.to_s.empty?
                   body = JSON.parse(http_response.payload)
-                  if body.is_a?(Hash) && body.key?(SERVICE_RATE_KEY)
-                    options[:service_rates] = body[SERVICE_RATE_KEY]
-                  end
+                  options[:service_rates] = body[SERVICE_RATE_KEY] if body.is_a?(Hash) && body.key?(SERVICE_RATE_KEY)
                 end
               end
 

data/lib/ddtrace/transport/io.rb

@@ -17,7 +17,7 @@ module Datadog
       # Pass options to override any settings.
       def default(options = {})
         new(
-          options.fetch(:out, STDOUT),
+          options.fetch(:out, $stdout),
           options.fetch(:encoder, Encoding::JSONEncoder)
         )
       end

data/lib/ddtrace/transport/io/response.rb

@@ -6,14 +6,12 @@ module Datadog
       # Response from HTTP transport for traces
       class Response
         include Transport::Response
-        include Transport::Traces::Response
 
         attr_reader \
           :result
 
-        def initialize(result, trace_count = 1)
+        def initialize(result)
           @result = result
-          @trace_count = trace_count
         end
 
         def ok?

data/lib/ddtrace/transport/io/traces.rb

@@ -10,6 +10,12 @@ module Datadog
       module Traces
         # Response from HTTP transport for traces
         class Response < IO::Response
+          include Transport::Traces::Response
+
+          def initialize(result, trace_count = 1)
+            super(result)
+            @trace_count = trace_count
+          end
         end
 
         # Extensions for HTTP client

data/lib/ddtrace/transport/traces.rb

@@ -123,7 +123,21 @@ module Datadog
                 return send_traces(traces)
               end
             end
-          end.force
+          end
+
+          # Force resolution of lazy enumerator.
+          #
+          # The "correct" method to call here would be `#force`,
+          # as this method was created to force the eager loading
+          # of a lazy enumerator.
+          #
+          # Unfortunately, JRuby < 9.2.9.0 erroneously eagerly loads
+          # the lazy Enumerator during intermediate steps.
+          # This forces us to use `#to_a`, as this method works for both
+          # lazy and regular Enumerators.
+          # Using `#to_a` can mask the fact that we expect a lazy
+          # Enumerator.
+          responses = responses.to_a
 
           Datadog.health_metrics.transport_chunked(responses.size)
 
@@ -142,17 +156,20 @@ module Datadog
 
         def downgrade?(response)
           return false unless apis.fallbacks.key?(@current_api_id)
+
           response.not_found? || response.unsupported?
         end
 
         def downgrade!
           downgrade_api_id = apis.fallbacks[@current_api_id]
           raise NoDowngradeAvailableError, @current_api_id if downgrade_api_id.nil?
+
           change_api!(downgrade_api_id)
         end
 
         def change_api!(api_id)
           raise UnknownApiVersionError, api_id unless apis.key?(api_id)
+
           @current_api_id = api_id
           @client = HTTP::Client.new(current_api)
         end

data/lib/ddtrace/utils.rb

@@ -1,8 +1,11 @@
 require 'ddtrace/utils/database'
+require 'ddtrace/utils/forking'
 
 module Datadog
   # Utils contains low-level utilities, typically to provide pseudo-random trace IDs.
   module Utils
+    extend Utils::Forking
+
     EMPTY_STRING = ''.encode(::Encoding::UTF_8).freeze
     # We use a custom random number generator because we want no interference
     # with the default one. Using the default prng, we could break code that
@@ -10,23 +13,19 @@ module Datadog
 
     # Return a span id
     def self.next_id
-      reset! if was_forked?
-
-      @rnd.rand(Datadog::Span::RUBY_MAX_ID)
+      after_fork! { reset! }
+      id_rng.rand(Datadog::Span::RUBY_MAX_ID)
     end
 
-    def self.reset!
-      @pid = Process.pid
-      @rnd = Random.new
+    def self.id_rng
+      @id_rng ||= Random.new
     end
 
-    def self.was_forked?
-      Process.pid != @pid
+    def self.reset!
+      @id_rng = Random.new
     end
 
-    private_class_method :reset!, :was_forked?
-
-    reset!
+    private_class_method :id_rng, :reset!
 
     def self.truncate(value, size, omission = '...'.freeze)
       string = value.to_s

data/lib/ddtrace/utils/compression.rb

@@ -0,0 +1,27 @@
+require 'zlib'
+
+module Datadog
+  module Utils
+    # Common database-related utility functions.
+    module Compression
+      module_function
+
+      def gzip(string, level: nil, strategy: nil)
+        sio = StringIO.new
+        sio.binmode
+        gz = Zlib::GzipWriter.new(sio, level, strategy)
+        gz.write(string)
+        gz.close
+        sio.string
+      end
+
+      def gunzip(string, encoding = ::Encoding::ASCII_8BIT)
+        sio = StringIO.new(string)
+        gz = Zlib::GzipReader.new(sio, encoding: encoding)
+        gz.read
+      ensure
+        gz && gz.close
+      end
+    end
+  end
+end

data/lib/ddtrace/utils/forking.rb

@@ -0,0 +1,52 @@
+module Datadog
+  module Utils
+    # Helper methods for managing forking behavior
+    module Forking
+      def self.included(base)
+        base.send(:prepend, ClassExtensions) if base.is_a?(Class)
+      end
+
+      def self.extended(base)
+        # Explicitly update PID here because there's a case where
+        # the code path that lazily updates the PID may not be exercised
+        # until after a fork occurs, thus causing the event to be missed.
+        # By eagerly setting this, we avoid this scenario.
+        base.update_fork_pid!
+      end
+
+      def after_fork!
+        if forked?
+          yield
+          update_fork_pid!
+          true
+        else
+          false
+        end
+      end
+
+      def forked?
+        Process.pid != fork_pid
+      end
+
+      def update_fork_pid!
+        @fork_pid = Process.pid
+      end
+
+      def fork_pid
+        @fork_pid ||= Process.pid
+      end
+
+      # Adds additional functionality for Classes that implement Forking
+      module ClassExtensions
+        # Addresses an edge case where forking before invoking #update_fork_pid! on the
+        # object will cause forking to not be detected in the fork when it should have.
+        #
+        # This wrapper prevents this by initializing the fork PID when the object is created.
+        def initialize(*args, &block)
+          super
+          update_fork_pid!
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/utils/object_set.rb

@@ -0,0 +1,41 @@
+require 'ddtrace/utils/sequence'
+
+module Datadog
+  module Utils
+    # Acts as a unique dictionary of objects
+    class ObjectSet
+      # You can provide a block that defines how the key
+      # for this message type is resolved.
+      def initialize(seed = 0, &block)
+        @sequence = Utils::Sequence.new(seed)
+        @items = {}
+        @key_block = block
+      end
+
+      # Submit an array of arguments that define the message.
+      # If they match an existing message, it will return the
+      # matching object. If it doesn't match, it will yield to
+      # the block with the next ID & args given.
+      def fetch(*args, &block)
+        key = @key_block ? @key_block.call(*args) : args.hash
+        # TODO: Ruby 2.0 doesn't like yielding here... switch when 2.0 is dropped.
+        # rubocop:disable Performance/RedundantBlockCall
+        @items[key] ||= block.call(@sequence.next, *args)
+        # rubocop:enable Performance/RedundantBlockCall
+      end
+
+      def length
+        @items.length
+      end
+
+      def objects
+        @items.values
+      end
+
+      def freeze
+        super
+        @items.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/utils/only_once.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Utils
+    # Helper class to execute something only once such as not repeating warning logs, and instrumenting classes
+    # only once.
+    #
+    # Thread-safe when used correctly (e.g. be careful of races when lazily initializing instances of this class).
+    #
+    # Note: In its current state, this class is not Ractor-safe.
+    # In https://github.com/DataDog/dd-trace-rb/pull/1398#issuecomment-797378810 we have a discussion of alternatives,
+    # including an alternative implementation that is Ractor-safe once spent.
+    class OnlyOnce
+      def initialize
+        @mutex = Mutex.new
+        @ran_once = false
+      end
+
+      def run
+        @mutex.synchronize do
+          return if @ran_once
+
+          @ran_once = true
+
+          yield
+        end
+      end
+
+      def ran?
+        @mutex.synchronize { @ran_once }
+      end
+
+      private
+
+      def reset_ran_once_state_for_tests
+        @mutex.synchronize { @ran_once = false }
+      end
+    end
+  end
+end

data/lib/ddtrace/utils/sequence.rb

@@ -0,0 +1,17 @@
+module Datadog
+  module Utils
+    # Generates values from a consistent sequence
+    class Sequence
+      def initialize(seed = 0, &block)
+        @current = seed
+        @next_item = block
+      end
+
+      def next
+        next_item = @next_item ? @next_item.call(@current) : @current
+        @current += 1
+        next_item
+      end
+    end
+  end
+end

data/lib/ddtrace/utils/string_table.rb

@@ -0,0 +1,45 @@
+require 'ddtrace/utils/sequence'
+
+module Datadog
+  module Utils
+    # Tracks strings and returns IDs
+    class StringTable
+      def initialize
+        @sequence = Sequence.new
+        @ids = { ''.freeze => @sequence.next }
+      end
+
+      # Returns an ID for the string
+      def fetch(string)
+        @ids[string.to_s] ||= @sequence.next
+      end
+
+      # Returns the canonical copy of this string
+      # Typically used for psuedo interning; reduce
+      # identical copies of a string to one object.
+      def fetch_string(string)
+        return nil if string.nil?
+
+        # Co-erce to string
+        string = string.to_s
+
+        # Add to string table if no match
+        @ids[string] = @sequence.next unless @ids.key?(string)
+
+        # Get and return matching string in table
+        # NOTE: Have to resolve the key and retrieve from table again
+        #       because "string" argument is not same object as string key.
+        id = @ids[string]
+        @ids.key(id)
+      end
+
+      def [](id)
+        @ids.key(id)
+      end
+
+      def strings
+        @ids.keys
+      end
+    end
+  end
+end