ddtrace 0.37.0 → 0.38.0

data/lib/ddtrace/sampler.rb

@@ -193,6 +193,8 @@ module Datadog
   class PrioritySampler
     extend Forwardable
 
+    attr_reader :pre_sampler, :priority_sampler
+
     SAMPLE_RATE_METRIC_KEY = '_sample_rate'.freeze
 
     def initialize(opts = {})

data/lib/ddtrace/span.rb

@@ -107,6 +107,16 @@ module Datadog
       Datadog.logger.debug("Unable to set the tag #{key}, ignoring it. Caused by: #{e}")
     end
 
+    # Sets tags from given hash, for each key in hash it sets the tag with that key
+    # and associated value from the hash. It is shortcut for `set_tag`. Keys and values
+    # of the hash must be strings. Note that nested hashes are not supported.
+    # A valid example is:
+    #
+    #   span.set_tags({ "http.method" => "GET", "user.id" => "234" })
+    def set_tags(tags)
+      tags.each { |k, v| set_tag(k, v) }
+    end
+
     # This method removes a tag for the given key.
     def clear_tag(key)
       @meta.delete(key)

data/lib/ddtrace/tracer.rb

@@ -212,8 +212,8 @@ 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.set_tags(@tags) unless @tags.empty?
+      span.set_tags(tags) unless tags.empty?
       span.start_time = start_time
 
       # this could at some point be optional (start_active_span vs start_manual_span)
@@ -255,9 +255,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 +271,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,

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

@@ -47,6 +47,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 +108,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

@@ -69,6 +69,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/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/version.rb

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

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 0.37.0
+  version: 0.38.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-24 00:00:00.000000000 Z
+date: 2020-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -546,7 +546,29 @@ files:
 - lib/ddtrace/contrib/http/integration.rb
 - lib/ddtrace/contrib/http/patcher.rb
 - lib/ddtrace/contrib/http_annotation_helper.rb
+- lib/ddtrace/contrib/httprb/configuration/settings.rb
+- lib/ddtrace/contrib/httprb/ext.rb
+- lib/ddtrace/contrib/httprb/instrumentation.rb
+- lib/ddtrace/contrib/httprb/integration.rb
+- lib/ddtrace/contrib/httprb/patcher.rb
 - lib/ddtrace/contrib/integration.rb
+- lib/ddtrace/contrib/kafka/configuration/settings.rb
+- lib/ddtrace/contrib/kafka/consumer_event.rb
+- lib/ddtrace/contrib/kafka/consumer_group_event.rb
+- lib/ddtrace/contrib/kafka/event.rb
+- lib/ddtrace/contrib/kafka/events.rb
+- lib/ddtrace/contrib/kafka/events/connection/request.rb
+- lib/ddtrace/contrib/kafka/events/consumer/process_batch.rb
+- lib/ddtrace/contrib/kafka/events/consumer/process_message.rb
+- lib/ddtrace/contrib/kafka/events/consumer_group/heartbeat.rb
+- lib/ddtrace/contrib/kafka/events/consumer_group/join_group.rb
+- lib/ddtrace/contrib/kafka/events/consumer_group/leave_group.rb
+- lib/ddtrace/contrib/kafka/events/consumer_group/sync_group.rb
+- lib/ddtrace/contrib/kafka/events/produce_operation/send_messages.rb
+- lib/ddtrace/contrib/kafka/events/producer/deliver_messages.rb
+- lib/ddtrace/contrib/kafka/ext.rb
+- lib/ddtrace/contrib/kafka/integration.rb
+- lib/ddtrace/contrib/kafka/patcher.rb
 - lib/ddtrace/contrib/mongodb/configuration/settings.rb
 - lib/ddtrace/contrib/mongodb/ext.rb
 - lib/ddtrace/contrib/mongodb/instrumentation.rb
@@ -647,6 +669,7 @@ files:
 - lib/ddtrace/contrib/sucker_punch/integration.rb
 - lib/ddtrace/contrib/sucker_punch/patcher.rb
 - lib/ddtrace/correlation.rb
+- lib/ddtrace/diagnostics/environment_logger.rb
 - lib/ddtrace/diagnostics/health.rb
 - lib/ddtrace/distributed_tracing/headers/b3.rb
 - lib/ddtrace/distributed_tracing/headers/b3_single.rb
@@ -784,7 +807,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.0.3
+rubyforge_project: 
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications