ddtrace 0.15.0.beta1 → 0.15.0.internaltracinfeature1

data/lib/ddtrace/propagation/distributed_headers.rb

@@ -16,15 +16,11 @@ module Datadog
     end
 
     def trace_id
-      value = header(HTTP_HEADER_TRACE_ID).to_i
-      return if value <= 0 || value >= Span::MAX_ID
-      value
+      id HTTP_HEADER_TRACE_ID
     end
 
     def parent_id
-      value = header(HTTP_HEADER_PARENT_ID).to_i
-      return if value <= 0 || value >= Span::MAX_ID
-      value
+      id HTTP_HEADER_PARENT_ID
     end
 
     def sampling_priority
@@ -44,5 +40,11 @@ module Datadog
 
       @env[rack_header]
     end
+
+    def id(header)
+      value = header(header).to_i
+      return if value.zero? || value >= Span::MAX_ID
+      value < 0 ? value + 0x1_0000_0000_0000_0000 : value
+    end
   end
 end

data/lib/ddtrace/registry.rb

@@ -25,8 +25,10 @@ module Datadog
     end
 
     def [](name)
-      entry = @data[name]
-      entry.klass if entry
+      @mutex.synchronize do
+        entry = @data[name]
+        entry.klass if entry
+      end
     end
 
     def to_h

data/lib/ddtrace/sampler.rb

@@ -98,14 +98,32 @@ module Datadog
     end
 
     def sample(span)
-      span.context.sampling_priority = Datadog::Ext::Priority::AUTO_REJECT if span.context
-      return unless @base_sampler.sample(span)
-      return unless @post_sampler.sample(span)
-      span.context.sampling_priority = Datadog::Ext::Priority::AUTO_KEEP if span.context
-
-      true
+      return perform_sampling(span) unless span.context
+      return sampled_by_upstream(span) if span.context.sampling_priority
+
+      perform_sampling(span).tap do |sampled|
+        span.context.sampling_priority = if sampled
+                                           Datadog::Ext::Priority::AUTO_KEEP
+                                         else
+                                           Datadog::Ext::Priority::AUTO_REJECT
+                                         end
+      end
     end
 
     def_delegators :@post_sampler, :update
+
+    private
+
+    def sampled_by_upstream(span)
+      span.sampled = priority_keep?(span.context.sampling_priority)
+    end
+
+    def priority_keep?(sampling_priority)
+      sampling_priority == Datadog::Ext::Priority::USER_KEEP || sampling_priority == Datadog::Ext::Priority::AUTO_KEEP
+    end
+
+    def perform_sampling(span)
+      @base_sampler.sample(span) && @post_sampler.sample(span)
+    end
   end
 end

data/lib/ddtrace/tracer.rb

@@ -20,7 +20,7 @@ module Datadog
   # rubocop:disable Metrics/ClassLength
   class Tracer
     attr_reader :sampler, :services, :tags, :provider
-    attr_accessor :enabled, :writer
+    attr_accessor :enabled, :writer, :internal_traces
     attr_writer :default_service
 
     ALLOWED_SPAN_OPTIONS = [:service, :resource, :span_type].freeze
@@ -102,7 +102,9 @@ module Datadog
       @provider ||= Datadog::DefaultContextProvider.new # @provider should never be nil
 
       @context_flush = options[:partial_flush] ? Datadog::ContextFlush.new(options) : nil
+      @internal_traces = options[:internal_traces] || false
 
+      @mutex = Mutex.new
       @services = {}
       @tags = {}
     end
@@ -122,6 +124,7 @@ module Datadog
       enabled = options.fetch(:enabled, nil)
       hostname = options.fetch(:hostname, nil)
       port = options.fetch(:port, nil)
+      @internal_traces = options.fetch(:internal_traces, false)
 
       # Those are rare "power-user" options.
       sampler = options.fetch(:sampler, nil)

data/lib/ddtrace/transport.rb

@@ -3,6 +3,7 @@ require 'net/http'
 
 require 'ddtrace/encoding'
 require 'ddtrace/version'
+require 'ddtrace/utils'
 
 module Datadog
   # Transport class that handles the spans delivery to the
@@ -10,6 +11,9 @@ module Datadog
   # so that the Transport is thread-safe.
   # rubocop:disable Metrics/ClassLength
   class HTTPTransport
+    include Datadog::Utils::InternalTraces
+    self.internal_trace_service = 'datadog.transport'.freeze
+
     attr_accessor :hostname, :port
     attr_reader :traces_endpoint, :services_endpoint
 
@@ -45,6 +49,12 @@ module Datadog
 
     private_constant :API
 
+    CONTENT_TYPE = 'Content-Type'.freeze
+    DATADOG_META_LANG = 'Datadog-Meta-Lang'.freeze
+    DATADOG_META_LANG_VERSION = 'Datadog-Meta-Lang-Version'.freeze
+    DATADOG_META_LANG_INTERPRETER = 'Datadog-Meta-Lang-Interpreter'.freeze
+    DATADOG_META_TRACER_VERSION = 'Datadog-Meta-Tracer-Version'.freeze
+
     def initialize(hostname, port, options = {})
       api_version = options.fetch(:api_version, V3)
 
@@ -56,11 +66,11 @@ module Datadog
 
       # overwrite the Content-type with the one chosen in the Encoder
       @headers = options.fetch(:headers, {})
-      @headers['Content-Type'] = @encoder.content_type
-      @headers['Datadog-Meta-Lang'] = 'ruby'
-      @headers['Datadog-Meta-Lang-Version'] = RUBY_VERSION
-      @headers['Datadog-Meta-Lang-Interpreter'] = RUBY_INTERPRETER
-      @headers['Datadog-Meta-Tracer-Version'] = Datadog::VERSION::STRING
+      @headers[CONTENT_TYPE] = @encoder.content_type
+      @headers[DATADOG_META_LANG] = 'ruby'.freeze
+      @headers[DATADOG_META_LANG_VERSION] = RUBY_VERSION
+      @headers[DATADOG_META_LANG_INTERPRETER] = RUBY_INTERPRETER
+      @headers[DATADOG_META_TRACER_VERSION] = Datadog::VERSION::STRING
 
       # stats
       @mutex = Mutex.new
@@ -68,32 +78,32 @@ module Datadog
       @count_client_error = 0
       @count_server_error = 0
       @count_internal_error = 0
+      @count_consecutive_errors = 0
     end
 
     # route the send to the right endpoint
     def send(endpoint, data)
-      case endpoint
-      when :services
-        payload = @encoder.encode_services(data)
-        status_code = post(@api[:services_endpoint], payload) do |response|
-          process_callback(:services, response)
-        end
-      when :traces
-        count = data.length
-        payload = @encoder.encode_traces(data)
-        status_code = post(@api[:traces_endpoint], payload, count) do |response|
-          process_callback(:traces, response)
+      internal_span_when(-> { do_trace?(data) }, 'datadog.send'.freeze) do
+        case endpoint
+        when :services
+          status_code = send_services(data)
+        when :traces
+          status_code = send_traces(data)
+        else
+          with_active_internal_span { |s| s.set_error(RuntimeError.new("Unsupported endpoint: #{endpoint}")) }
+
+          Datadog::Tracer.log.error("Unsupported endpoint: #{endpoint}")
+          return nil
         end
-      else
-        Datadog::Tracer.log.error("Unsupported endpoint: #{endpoint}")
-        return nil
-      end
 
-      if downgrade?(status_code)
-        downgrade!
-        send(endpoint, data)
-      else
-        status_code
+        if downgrade?(status_code)
+          internal_child_span('datadog.send.downgrade'.freeze) do
+            downgrade!
+            send(endpoint, data)
+          end
+        else
+          status_code
+        end
       end
     end
 
@@ -105,11 +115,12 @@ module Datadog
         headers = headers.merge(@headers)
         request = Net::HTTP::Post.new(url, headers)
         request.body = data
-
         response = Net::HTTP.start(@hostname, @port, read_timeout: TIMEOUT) { |http| http.request(request) }
         handle_response(response)
       rescue StandardError => e
-        Datadog::Tracer.log.error(e.message)
+        with_active_internal_span { |s| s.set_error(e) }
+
+        log_error_once(e.message)
         500
       end.tap do
         yield(response) if block_given?
@@ -125,7 +136,7 @@ module Datadog
 
         @api = API.fetch(fallback_version)
         @encoder = @api[:encoder].new
-        @headers['Content-Type'] = @encoder.content_type
+        @headers[CONTENT_TYPE] = @encoder.content_type
       end
     end
 
@@ -167,24 +178,27 @@ module Datadog
     # function is handled within the HTTP mutex.synchronize so it's thread-safe.
     def handle_response(response)
       status_code = response.code.to_i
+      with_active_internal_span { |s| s.set_tag('response.code', status_code) }
 
       if success?(status_code)
-        Datadog::Tracer.log.debug('Payload correctly sent to the trace agent.')
+        Datadog::Tracer.log.debug('Payload correctly sent to the trace agent.'.freeze)
+        @mutex.synchronize { @count_consecutive_errors = 0 }
         @mutex.synchronize { @count_success += 1 }
       elsif downgrade?(status_code)
         Datadog::Tracer.log.debug("calling the endpoint but received #{status_code}; downgrading the API")
       elsif client_error?(status_code)
-        Datadog::Tracer.log.error("Client error: #{response.message}")
+        log_error_once("Client error: #{response.message}")
         @mutex.synchronize { @count_client_error += 1 }
       elsif server_error?(status_code)
-        Datadog::Tracer.log.error("Server error: #{response.message}")
-        @mutex.synchronize { @count_server_error += 1 }
+        log_error_once("Server error: #{response.message}")
       end
 
       status_code
     rescue StandardError => e
-      Datadog::Tracer.log.error(e.message)
+      log_error_once(e.message)
       @mutex.synchronize { @count_internal_error += 1 }
+      with_active_internal_span { |s| s.set_error(e) }
+
       500
     end
 
@@ -201,6 +215,64 @@ module Datadog
 
     private
 
+    def do_trace?(data)
+      # Create the span if we already are traced
+      return true if Datadog.tracer.active_span
+      # Don't trace empty data
+      return false unless data
+
+      # over 3 traces means that we most certainly send more than only internal traces
+      return true if data.length > 3
+
+      # all spans in all traces shouldn't be only 'datadog.internal' spans
+      !data.respond_to?(:all?) || data.all? do |trace|
+        !trace.respond_to?(:none?) || trace.none? do |span|
+          span.respond_to?(:get_tag) && span.get_tag(Utils::InternalTraces::INTERNAL_TAG)
+        end
+      end
+    end
+
+    def send_traces(data)
+      count = data.length
+
+      payload = internal_child_span('datadog.encode.traces'.freeze) do
+        with_active_internal_span { |s| s.set_tag('traces.count'.freeze, count) }
+        @encoder.encode_traces(data)
+      end
+
+      internal_child_span('datadog.traces.post'.freeze) do
+        post(@api[:traces_endpoint], payload, count) do |response|
+          internal_child_span('datadog.traces.response_callback'.freeze) do
+            process_callback(:traces, response)
+          end
+        end
+      end
+    end
+
+    def send_services(data)
+      payload = internal_child_span('datadog.services.encode'.freeze) do
+        @encoder.encode_services(data)
+      end
+
+      internal_child_span('datadog.services.post'.freeze) do
+        post(@api[:services_endpoint], payload) do |response|
+          internal_child_span('datadog.services.response_callback'.freeze) do
+            process_callback(:services, response)
+          end
+        end
+      end
+    end
+
+    def log_error_once(*args)
+      if @count_consecutive_errors > 0
+        Datadog::Tracer.log.debug(*args)
+      else
+        Datadog::Tracer.log.error(*args)
+      end
+
+      @mutex.synchronize { @count_consecutive_errors += 1 }
+    end
+
     def process_callback(action, response)
       return unless @response_callback && @response_callback.respond_to?(:call)
 

data/lib/ddtrace/utils.rb

@@ -1,4 +1,5 @@
 require 'ddtrace/utils/database'
+require 'ddtrace/utils/internal_traces'
 
 module Datadog
   # Utils contains low-level utilities, typically to provide pseudo-random trace IDs.

data/lib/ddtrace/utils/internal_traces.rb

@@ -0,0 +1,53 @@
+module Datadog
+  module Utils
+    # Traces generated by the client internals
+    module InternalTraces
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      # ClassMethods
+      module ClassMethods
+        attr_writer :internal_trace_service
+
+        def internal_trace_service
+          @internal_trace_service ||= 'datadog.unknown'.freeze
+        end
+      end
+
+      INTERNAL_TAG = 'datadog.internal'.freeze
+
+      def internal_span(name, *args)
+        return yield unless Datadog.tracer.internal_traces
+
+        Datadog.tracer.trace(name, *args) do |span|
+          span.set_tag(INTERNAL_TAG, true)
+          span.service = self.class.internal_trace_service
+          yield
+        end
+      end
+
+      def internal_span_when(condition, name, *args, &block)
+        return yield unless Datadog.tracer.internal_traces
+
+        condition = condition.call if condition.respond_to?(:send)
+        return yield unless condition
+
+        internal_span(name, *args, &block)
+      end
+
+      def internal_child_span(name, *args, &block)
+        return yield unless Datadog.tracer.internal_traces
+
+        internal_span_when(-> { Datadog.tracer.active_span }, name, *args, &block)
+      end
+
+      def with_active_internal_span
+        return unless Datadog.tracer.internal_traces
+
+        span = Datadog.tracer.active_span
+        yield(span) if span && span.get_tag(INTERNAL_TAG)
+      end
+    end
+  end
+end

data/lib/ddtrace/version.rb

@@ -3,7 +3,7 @@ module Datadog
     MAJOR = 0
     MINOR = 15
     PATCH = 0
-    PRE = 'beta1'.freeze
+    PRE = 'internaltracinfeature1'
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 0.15.0.beta1
+  version: 0.15.0.internaltracinfeature1
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-17 00:00:00.000000000 Z
+date: 2018-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -299,6 +299,11 @@ files:
 - lib/ddtrace/contrib/aws/patcher.rb
 - lib/ddtrace/contrib/aws/services.rb
 - lib/ddtrace/contrib/base.rb
+- lib/ddtrace/contrib/concurrent_ruby/configuration/settings.rb
+- lib/ddtrace/contrib/concurrent_ruby/context_composite_executor_service.rb
+- lib/ddtrace/contrib/concurrent_ruby/future_patch.rb
+- lib/ddtrace/contrib/concurrent_ruby/integration.rb
+- lib/ddtrace/contrib/concurrent_ruby/patcher.rb
 - lib/ddtrace/contrib/configurable.rb
 - lib/ddtrace/contrib/configuration/option.rb
 - lib/ddtrace/contrib/configuration/option_definition.rb
@@ -415,6 +420,7 @@ files:
 - lib/ddtrace/transport.rb
 - lib/ddtrace/utils.rb
 - lib/ddtrace/utils/database.rb
+- lib/ddtrace/utils/internal_traces.rb
 - lib/ddtrace/vendor/active_record/connection_specification.rb
 - lib/ddtrace/version.rb
 - lib/ddtrace/workers.rb
@@ -440,7 +446,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications