ddtrace 0.46.0 → 0.47.0

data/lib/ddtrace/runtime/cgroup.rb

@@ -21,7 +21,7 @@ module Datadog
             filepath = "/proc/#{process}/cgroup"
 
             if File.exist?(filepath)
-              File.open("/proc/#{process}/cgroup").each do |line|
+              File.foreach("/proc/#{process}/cgroup") do |line|
                 line = line.strip
                 descriptors << parse(line) unless line.empty?
               end

data/lib/ddtrace/runtime/container.rb

@@ -32,39 +32,37 @@ module Datadog
       end
 
       def descriptor
-        @descriptor ||= begin
-          Descriptor.new.tap do |descriptor|
-            begin
-              Cgroup.descriptors.each do |cgroup_descriptor|
-                # Parse container data from cgroup descriptor
-                path = cgroup_descriptor.path
-                next if path.nil?
+        @descriptor ||= Descriptor.new.tap do |descriptor|
+          begin
+            Cgroup.descriptors.each do |cgroup_descriptor|
+              # Parse container data from cgroup descriptor
+              path = cgroup_descriptor.path
+              next if path.nil?
 
-                # Split path into parts
-                parts = path.split('/')
-                parts.shift # Remove leading empty part
-                next if parts.length < 2
+              # Split path into parts
+              parts = path.split('/')
+              parts.shift # Remove leading empty part
+              next if parts.length < 2
 
-                # Read info from path
-                platform = parts[0]
-                container_id = parts[-1][CONTAINER_REGEX]
-                task_uid = parts[-2][POD_REGEX]
+              # Read info from path
+              platform = parts[0]
+              container_id = parts[-1][CONTAINER_REGEX]
+              task_uid = parts[-2][POD_REGEX]
 
-                # If container ID wasn't found, ignore.
-                # Path might describe a non-container environment.
-                next if container_id.nil?
+              # If container ID wasn't found, ignore.
+              # Path might describe a non-container environment.
+              next if container_id.nil?
 
-                descriptor.platform = platform
-                descriptor.container_id = container_id
-                descriptor.task_uid = task_uid
+              descriptor.platform = platform
+              descriptor.container_id = container_id
+              descriptor.task_uid = task_uid
 
-                break
-              end
-            rescue StandardError => e
-              Datadog.logger.error(
-                "Error while parsing container info. Cause: #{e.message} Location: #{e.backtrace.first}"
-              )
+              break
             end
+          rescue StandardError => e
+            Datadog.logger.error(
+              "Error while parsing container info. Cause: #{e.message} Location: #{e.backtrace.first}"
+            )
           end
         end
       end

data/lib/ddtrace/runtime/identity.rb

@@ -24,10 +24,18 @@ module Datadog
         Ext::Runtime::LANG
       end
 
+      def lang_engine
+        Ext::Runtime::LANG_ENGINE
+      end
+
       def lang_interpreter
         Ext::Runtime::LANG_INTERPRETER
       end
 
+      def lang_platform
+        Ext::Runtime::LANG_PLATFORM
+      end
+
       def lang_version
         Ext::Runtime::LANG_VERSION
       end

data/lib/ddtrace/sync_writer.rb

@@ -1,6 +1,7 @@
 require 'ddtrace/ext/net'
 require 'ddtrace/runtime/socket'
 require 'ddtrace/runtime/metrics'
+require 'ddtrace/utils/only_once'
 
 module Datadog
   # SyncWriter flushes both services and traces synchronously
@@ -10,6 +11,8 @@ module Datadog
   # the separate `datadog-lambda` uses it as of February 2021:
   # <https://github.com/DataDog/datadog-lambda-rb/blob/c15f0f0916c90123416dc44e7d6800ef4a7cfdbf/lib/datadog/lambda.rb#L38>
   class SyncWriter
+    DEPRECATION_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
     attr_reader \
       :priority_sampler,
       :transport
@@ -25,10 +28,10 @@ module Datadog
 
     def write(trace, services = nil)
       unless services.nil?
-        Datadog::Patcher.do_once('SyncWriter#write') do
+        DEPRECATION_WARN_ONLY_ONCE.run do
           Datadog.logger.warn(%(
             write: Writing services has been deprecated and no longer need to be provided.
-            write(traces, services) can be updted to write(traces)
+            write(traces, services) can be updated to write(traces)
           ))
         end
       end

data/lib/ddtrace/tracer.rb

@@ -10,6 +10,7 @@ require 'ddtrace/runtime/identity'
 require 'ddtrace/sampler'
 require 'ddtrace/sampling'
 require 'ddtrace/correlation'
+require 'ddtrace/utils/only_once'
 
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
 module Datadog
@@ -19,6 +20,9 @@ module Datadog
   # of these function calls and sub-requests would be encapsulated within a single trace.
   # rubocop:disable Metrics/ClassLength
   class Tracer
+    SERVICES_DEPRECATION_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+    SET_SERVICE_INFO_DEPRECATION_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
     attr_reader :sampler, :tags, :provider, :context_flush
     attr_accessor :enabled, :writer
     attr_writer :default_service
@@ -27,8 +31,7 @@ module Datadog
     DEFAULT_ON_ERROR = proc { |span, error| span.set_error(error) unless span.nil? }
 
     def services
-      # Only log each deprecation warning once (safeguard against log spam)
-      Datadog::Patcher.do_once('Tracer#set_service_info') do
+      SERVICES_DEPRECATION_WARN_ONLY_ONCE.run do
         Datadog.logger.warn('services: Usage of Tracer.services has been deprecated')
       end
 
@@ -129,8 +132,7 @@ module Datadog
     #
     # set_service_info is deprecated, no service information needs to be tracked
     def set_service_info(service, app, app_type)
-      # Only log each deprecation warning once (safeguard against log spam)
-      Datadog::Patcher.do_once('Tracer#set_service_info') do
+      SET_SERVICE_INFO_DEPRECATION_WARN_ONLY_ONCE.run do
         Datadog.logger.warn(%(
           set_service_info: Usage of set_service_info has been deprecated,
           service information no longer needs to be reported to the trace agent.

data/lib/ddtrace/transport/http.rb

@@ -27,7 +27,7 @@ module Datadog
       # Pass a block to override any settings.
       def default(options = {})
         new do |transport|
-          transport.adapter :net_http, default_hostname, default_port
+          transport.adapter default_adapter, default_hostname, default_port, timeout: 1
           transport.headers default_headers
 
           apis = API.defaults
@@ -39,10 +39,15 @@ module Datadog
           # Apply any settings given by options
           unless options.empty?
             # Change hostname/port
-            if options.key?(:hostname) || options.key?(:port)
-              hostname = options.fetch(:hostname, default_hostname)
-              port = options.fetch(:port, default_port)
-              transport.adapter :net_http, hostname, port
+            if [:hostname, :port, :timeout, :ssl].any? { |key| options.key?(key) }
+              hostname = options[:hostname] || default_hostname
+              port = options[:port] || default_port
+
+              adapter_options = { timeout: 1 }
+              adapter_options[:timeout] = options[:timeout] if options.key?(:timeout)
+              adapter_options[:ssl] = options[:ssl] if options.key?(:ssl)
+
+              transport.adapter default_adapter, hostname, port, adapter_options
             end
 
             # Change default API
@@ -73,6 +78,10 @@ module Datadog
         end
       end
 
+      def default_adapter
+        :net_http
+      end
+
       def default_hostname
         return default_url.hostname if default_url
 

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

@@ -1,4 +1,5 @@
 require 'ddtrace/transport/response'
+require 'ddtrace/vendor/multipart-post/net/http/post/multipart'
 
 module Datadog
   module Transport
@@ -9,14 +10,16 @@ module Datadog
           attr_reader \
             :hostname,
             :port,
-            :timeout
+            :timeout,
+            :ssl
 
-          DEFAULT_TIMEOUT = 1
+          DEFAULT_TIMEOUT = 30
 
           def initialize(hostname, port, options = {})
             @hostname = hostname
             @port = port
             @timeout = options[:timeout] || DEFAULT_TIMEOUT
+            @ssl = options.key?(:ssl) ? options[:ssl] == true : false
           end
 
           def open(&block)
@@ -25,6 +28,7 @@ module Datadog
             # https://github.com/ruby/ruby/blob/b2d96abb42abbe2e01f010ffc9ac51f0f9a50002/lib/net/http.rb#L614-L618
             req = ::Net::HTTP.new(hostname, port, nil)
 
+            req.use_ssl = ssl
             req.open_timeout = req.read_timeout = timeout
 
             req.start(&block)
@@ -39,8 +43,18 @@ module Datadog
           end
 
           def post(env)
-            post = ::Net::HTTP::Post.new(env.path, env.headers)
-            post.body = env.body
+            post = nil
+
+            if env.form.nil? || env.form.empty?
+              post = ::Net::HTTP::Post.new(env.path, env.headers)
+              post.body = env.body
+            else
+              post = ::Datadog::Vendor::Net::HTTP::Post::Multipart.new(
+                env.path,
+                env.form,
+                env.headers
+              )
+            end
 
             # Connect and send the request
             http_response = open do |http|

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

@@ -95,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
@@ -107,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/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)
 

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/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