ddtrace 0.36.0 → 0.41.0

data/lib/ddtrace/tracer.rb

@@ -1,4 +1,3 @@
-require 'pp'
 require 'thread'
 require 'logger'
 require 'pathname'
@@ -186,8 +185,7 @@ module Datadog
     # * +start_time+: when the span actually starts (defaults to \now)
     # * +tags+: extra tags which should be added to the span.
     def start_span(name, options = {})
-      start_time = options.fetch(:start_time, Time.now.utc)
-
+      start_time = options[:start_time]
       tags = options.fetch(:tags, {})
 
       span_options = options.select do |k, _v|
@@ -212,9 +210,10 @@ module Datadog
         # child span
         span.parent = parent # sets service, trace_id, parent_id, sampled
       end
-      @tags.each { |k, v| span.set_tag(k, v) } unless @tags.empty?
-      tags.each { |k, v| span.set_tag(k, v) } unless tags.empty?
-      span.start_time = start_time
+
+      span.set_tags(@tags) unless @tags.empty?
+      span.set_tags(tags) unless tags.empty?
+      span.start(start_time)
 
       # this could at some point be optional (start_active_span vs start_manual_span)
       ctx.add_span(span) unless ctx.nil?
@@ -255,9 +254,11 @@ module Datadog
     # * +service+: the service name for this span
     # * +resource+: the resource this span refers, or \name if it's missing
     # * +span_type+: the type of the span (such as \http, \db and so on)
+    # * +child_of+: a \Span or a \Context instance representing the parent for this span.
+    #   If not set, defaults to Tracer.call_context
     # * +tags+: extra tags which should be added to the span.
     def trace(name, options = {})
-      options[:child_of] = call_context
+      options[:child_of] ||= call_context
 
       # call the finish only if a block is given; this ensures
       # that a call to tracer.trace() without a block, returns
@@ -269,11 +270,16 @@ module Datadog
         begin
           begin
             span = start_span(name, options)
-          # rubocop:disable Lint/UselessAssignment
           rescue StandardError => e
-            Datadog.logger.debug('Failed to start span: #{e}')
+            Datadog.logger.debug("Failed to start span: #{e}")
           ensure
-            return_value = yield(span)
+            # We should yield to the provided block when possible, as this
+            # block is application code that we don't want to hinder. We call:
+            # * `yield(span)` during normal execution.
+            # * `yield(nil)` if `start_span` fails with a runtime error.
+            # * We don't yield during a fatal error, as the application is likely trying to
+            #   end its execution (either due to a system error or graceful shutdown).
+            return_value = yield(span) if span || e.is_a?(StandardError)
           end
         # rubocop:disable Lint/RescueException
         # Here we really want to catch *any* exception, not only StandardError,
@@ -314,7 +320,7 @@ module Datadog
     def record_context(context)
       trace = @context_flush.consume!(context)
 
-      write(trace) if trace && !trace.empty?
+      write(trace) if @enabled && trace && !trace.empty?
     end
 
     # Return the current active span or +nil+.
@@ -335,7 +341,7 @@ module Datadog
     # Send the trace to the writer to enqueue the spans list in the agent
     # sending queue.
     def write(trace)
-      return if @writer.nil? || !@enabled
+      return if @writer.nil?
 
       if Datadog.configuration.diagnostics.debug
         Datadog.logger.debug("Writing #{trace.length} spans (enabled: #{@enabled})")

data/lib/ddtrace/transport/http.rb

@@ -10,6 +10,7 @@ require 'ddtrace/transport/http/api'
 require 'ddtrace/transport/http/adapters/net'
 require 'ddtrace/transport/http/adapters/test'
 require 'ddtrace/transport/http/adapters/unix_socket'
+require 'uri'
 
 module Datadog
   module Transport
@@ -75,13 +76,27 @@ module Datadog
       end
 
       def default_hostname
+        return default_url.hostname if default_url
+
         ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST, Datadog::Ext::Transport::HTTP::DEFAULT_HOST)
       end
 
       def default_port
+        return default_url.port if default_url
+
         ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT, Datadog::Ext::Transport::HTTP::DEFAULT_PORT).to_i
       end
 
+      def default_url
+        url_env = ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL, nil)
+
+        if url_env
+          uri_parsed = URI.parse(url_env)
+
+          uri_parsed if %w[http https].include?(uri_parsed.scheme)
+        end
+      end
+
       # Add adapters to registry
       Builder::REGISTRY.set(Adapters::Net, :net_http)
       Builder::REGISTRY.set(Adapters::Test, :test)

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

@@ -20,8 +20,14 @@ module Datadog
           end
 
           def open
-            # Open connection
-            ::Net::HTTP.start(hostname, port, open_timeout: timeout, read_timeout: timeout) do |http|
+            # DEV Initializing +Net::HTTP+ directly help us avoid expensive
+            # options processing done in +Net::HTTP.start+:
+            # https://github.com/ruby/ruby/blob/b2d96abb42abbe2e01f010ffc9ac51f0f9a50002/lib/net/http.rb#L614-L618
+            req = ::Net::HTTP.new(hostname, port, nil)
+
+            req.open_timeout = req.read_timeout = timeout
+
+            req.start do |http|
               yield(http)
             end
           end
@@ -47,6 +53,10 @@ module Datadog
             Response.new(http_response)
           end
 
+          def url
+            "http://#{hostname}:#{port}?timeout=#{timeout}"
+          end
+
           # Raised when called with an unknown HTTP method
           class UnknownHTTPMethod < StandardError
             attr_reader :verb
@@ -104,6 +114,10 @@ module Datadog
               return super if http_response.nil?
               code.between?(500, 599)
             end
+
+            def inspect
+              "#{super}, http_response:#{http_response}"
+            end
           end
         end
       end

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

@@ -33,6 +33,8 @@ module Datadog
             @status = status
           end
 
+          def url; end
+
           # Response for test adapter
           class Response
             include Datadog::Transport::Response
@@ -69,6 +71,10 @@ module Datadog
             def server_error?
               code.between?(500, 599)
             end
+
+            def inspect
+              "#{super}, code:#{code}"
+            end
           end
         end
       end

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

@@ -31,6 +31,10 @@ module Datadog
             end
           end
 
+          def url
+            "http+unix://#{filepath}?timeout=#{timeout}"
+          end
+
           # Re-implements Net:HTTP with underlying Unix socket
           class HTTP < ::Net::HTTP
             DEFAULT_TIMEOUT = 1

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

@@ -18,11 +18,24 @@ module Datadog
               # Add status code tag to api.responses metric
               if metrics.key?(:api_responses)
                 (metrics[:api_responses].options[:tags] ||= []).tap do |tags|
-                  tags << "status_code:#{response.code}"
+                  tags << metrics_tag_value(response.code)
                 end
               end
             end
           end
+
+          private
+
+          # The most common status code on a healthy tracer
+          STATUS_CODE_200 = 'status_code:200'.freeze
+
+          def metrics_tag_value(status_code)
+            if status_code == 200
+              STATUS_CODE_200 # DEV Saves string concatenation/creation for common case
+            else
+              "status_code:#{status_code}"
+            end
+          end
         end
       end
     end

data/lib/ddtrace/transport/response.rb

@@ -29,6 +29,13 @@ module Datadog
       def internal_error?
         nil
       end
+
+      def inspect
+        "#{self.class} ok?:#{ok?} unsupported?:#{unsupported?}, " \
+        "not_found?:#{not_found?}, client_error?:#{client_error?}, " \
+        "server_error?:#{server_error?}, internal_error?:#{internal_error?}, " \
+        "payload:#{payload}"
+      end
     end
 
     # A generic error response for internal errors
@@ -44,6 +51,10 @@ module Datadog
       def internal_error?
         true
       end
+
+      def inspect
+        "#{super}, error_type:#{error.class} error:#{error}"
+      end
     end
   end
 end

data/lib/ddtrace/transport/traces.rb

@@ -57,7 +57,12 @@ module Datadog
         # @return [Enumerable[Array[Bytes,Integer]]] list of encoded chunks: each containing a byte array and
         #   number of traces
         def encode_in_chunks(traces)
-          encoded_traces = traces.map { |t| encode_one(t) }.reject(&:nil?)
+          encoded_traces = if traces.respond_to?(:filter_map)
+                             # DEV Supported since Ruby 2.7, saves an intermediate object creation
+                             traces.filter_map { |t| encode_one(t) }
+                           else
+                             traces.map { |t| encode_one(t) }.reject(&:nil?)
+                           end
 
           Datadog::Chunker.chunk_by_size(encoded_traces, max_size).map do |chunk|
             [encoder.join(chunk), chunk.size]
@@ -86,7 +91,7 @@ module Datadog
         module_function
 
         def encode_trace(encoder, trace)
-          encoder.encode(trace.map(&:to_hash))
+          encoder.encode(trace)
         end
       end
 

data/lib/ddtrace/utils.rb

@@ -3,7 +3,7 @@ require 'ddtrace/utils/database'
 module Datadog
   # Utils contains low-level utilities, typically to provide pseudo-random trace IDs.
   module Utils
-    STRING_PLACEHOLDER = ''.encode(::Encoding::UTF_8).freeze
+    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
     # would rely on srand/rand sequences.
@@ -12,7 +12,7 @@ module Datadog
     def self.next_id
       reset! if was_forked?
 
-      @rnd.rand(Datadog::Span::MAX_ID)
+      @rnd.rand(Datadog::Span::RUBY_MAX_ID)
     end
 
     def self.reset!
@@ -53,13 +53,17 @@ module Datadog
         str.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
       elsif str.encoding == ::Encoding::UTF_8
         str
+      elsif str.empty?
+        # DEV Optimization as `nil.to_s` is a very common source for an empty string,
+        # DEV but it comes encoded as US_ASCII.
+        EMPTY_STRING
       else
         str.encode(::Encoding::UTF_8)
       end
     rescue => e
       Datadog.logger.debug("Error encoding string in UTF-8: #{e}")
 
-      options.fetch(:placeholder, STRING_PLACEHOLDER)
+      options.fetch(:placeholder, EMPTY_STRING)
     end
   end
 end

data/lib/ddtrace/version.rb

@@ -1,7 +1,7 @@
 module Datadog
   module VERSION
     MAJOR = 0
-    MINOR = 36
+    MINOR = 41
     PATCH = 0
     PRE = nil
 

data/lib/ddtrace/workers/async.rb

@@ -42,7 +42,7 @@ module Datadog
         end
 
         def run_async?
-          @run_async = false unless instance_variable_defined?(:@run_async)
+          return false unless instance_variable_defined?(:@run_async)
           @run_async == true
         end
 
@@ -55,7 +55,7 @@ module Datadog
         end
 
         def error?
-          @error = nil unless instance_variable_defined?(:@error)
+          return false unless instance_variable_defined?(:@error)
           !@error.nil?
         end
 

data/lib/ddtrace/workers/loop.rb

@@ -33,7 +33,7 @@ module Datadog
       end
 
       def run_loop?
-        @run_loop = false unless instance_variable_defined?(:@run_loop)
+        return false unless instance_variable_defined?(:@run_loop)
         @run_loop == true
       end
 

data/lib/ddtrace/workers/polling.rb

@@ -34,7 +34,7 @@ module Datadog
       end
 
       def enabled?
-        @enabled = true unless instance_variable_defined?(:@enabled)
+        return true unless instance_variable_defined?(:@enabled)
         @enabled
       end
 

data/lib/ddtrace/workers/trace_writer.rb

@@ -72,6 +72,9 @@ module Datadog
         end
       end
 
+      # TODO: Register `Datadog::Diagnostics::EnvironmentLogger.log!`
+      # TODO: as a flush_completed subscriber when the `TraceWriter`
+      # TODO: instantiation code is implemented.
       def flush_completed
         @flush_completed ||= FlushCompleted.new
       end

data/lib/ddtrace/writer.rb

@@ -7,6 +7,7 @@ require 'ddtrace/transport/http'
 require 'ddtrace/transport/io'
 require 'ddtrace/encoding'
 require 'ddtrace/workers'
+require 'ddtrace/diagnostics/environment_logger'
 
 module Datadog
   # Processor that sends traces and metadata to the agent
@@ -43,9 +44,18 @@ module Datadog
       @worker = nil
     end
 
-    # spawns a worker for spans; they share the same transport which is thread-safe
     def start
-      @pid = Process.pid
+      @mutex_after_fork.synchronize do
+        pid = Process.pid
+        return if @worker && pid == @pid
+        @pid = pid
+        start_worker
+        true
+      end
+    end
+
+    # spawns a worker for spans; they share the same transport which is thread-safe
+    def start_worker
       @trace_handler = ->(items, transport) { send_spans(items, transport) }
       @worker = Datadog::Workers::AsyncTransport.new(
         transport: @transport,
@@ -57,14 +67,19 @@ module Datadog
       @worker.start
     end
 
-    # stops worker for spans.
     def stop
-      return if worker.nil?
+      @mutex_after_fork.synchronize { stop_worker }
+    end
+
+    def stop_worker
+      return if @worker.nil?
       @worker.stop
       @worker = nil
       true
     end
 
+    private :start_worker, :stop_worker
+
     # flush spans to the trace-agent, handles spans only
     def send_spans(traces, transport)
       return true if traces.empty?
@@ -83,6 +98,8 @@ module Datadog
       # Update priority sampler
       update_priority_sampler(responses.last)
 
+      record_environment_information!(responses)
+
       # Return if server error occurred.
       !responses.find(&:server_error?)
     end
@@ -106,13 +123,7 @@ module Datadog
       #
       # This check ensures that if a process doesn't own the current +Writer+, async workers
       # will be initialized again (but only once for each process).
-      pid = Process.pid
-      if pid != @pid # avoid using Mutex when pids are equal
-        @mutex_after_fork.synchronize do
-          # we should start threads because the worker doesn't own this
-          start if pid != @pid
-        end
-      end
+      start if @worker.nil? || @pid != Process.pid
 
       # TODO: Remove this, and have the tracer pump traces directly to runtime metrics
       #       instead of working through the trace writer.
@@ -121,7 +132,13 @@ module Datadog
         Datadog.runtime_metrics.associate_with_span(trace.first)
       end
 
-      @worker.enqueue_trace(trace)
+      worker_local = @worker
+
+      if worker_local
+        worker_local.enqueue_trace(trace)
+      else
+        Datadog.logger.debug('Writer either failed to start or was stopped before #write could complete')
+      end
     end
 
     # stats returns a dictionary of stats about the writer.
@@ -150,5 +167,9 @@ module Datadog
 
       priority_sampler.update(response.service_rates)
     end
+
+    def record_environment_information!(responses)
+      Diagnostics::EnvironmentLogger.log!(responses)
+    end
   end
 end