ddtrace 0.28.0 → 0.29.0

data/lib/ddtrace/diagnostics/health.rb

@@ -0,0 +1,30 @@
+require 'ddtrace/ext/diagnostics'
+require 'ddtrace/metrics'
+
+module Datadog
+  module Diagnostics
+    # Health-related diagnostics
+    module Health
+      # Health metrics for diagnostics
+      class Metrics < ::Datadog::Metrics
+        count :api_errors, Ext::Diagnostics::Health::Metrics::METRIC_API_ERRORS
+        count :api_requests, Ext::Diagnostics::Health::Metrics::METRIC_API_REQUESTS
+        count :api_responses, Ext::Diagnostics::Health::Metrics::METRIC_API_RESPONSES
+        count :queue_accepted, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_ACCEPTED
+        count :queue_accepted_lengths, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_ACCEPTED_LENGTHS
+        count :queue_dropped, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_DROPPED
+        gauge :queue_length, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_LENGTH
+        gauge :queue_max_length, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_MAX_LENGTH
+        gauge :queue_spans, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_SPANS
+        count :traces_filtered, Ext::Diagnostics::Health::Metrics::METRIC_TRACES_FILTERED
+        count :writer_cpu_time, Ext::Diagnostics::Health::Metrics::METRIC_WRITER_CPU_TIME
+      end
+
+      module_function
+
+      def metrics
+        Datadog.configuration.diagnostics.health_metrics
+      end
+    end
+  end
+end

data/lib/ddtrace/distributed_tracing/headers/datadog.rb

@@ -28,7 +28,7 @@ module Datadog
           # Return early if this propagation is not valid
           # DEV: To be valid we need to have a trace id and a parent id or when it is a synthetics trace, just the trace id
           # DEV: `DistributedHeaders#id` will not return 0
-          return unless (trace_id && parent_id) || (origin == 'synthetics' && trace_id)
+          return unless (trace_id && parent_id) || (origin && trace_id)
 
           # Return new context
           ::Datadog::Context.new(trace_id: trace_id,

data/lib/ddtrace/distributed_tracing/headers/headers.rb

@@ -13,6 +13,8 @@ module Datadog
           @env = env
         end
 
+        # TODO: Don't assume Rack format.
+        #       Make distributed tracing headers apathetic.
         def header(name)
           rack_header = "http-#{name}".upcase!.tr('-', '_')
 

data/lib/ddtrace/ext/diagnostics.rb

@@ -0,0 +1,25 @@
+module Datadog
+  module Ext
+    module Diagnostics
+      # Health
+      module Health
+        # Metrics
+        module Metrics
+          ENV_ENABLED = 'DD_HEALTH_METRICS_ENABLED'.freeze
+
+          METRIC_API_ERRORS = 'datadog.tracer.api.errors'.freeze
+          METRIC_API_REQUESTS = 'datadog.tracer.api.requests'.freeze
+          METRIC_API_RESPONSES = 'datadog.tracer.api.responses'.freeze
+          METRIC_QUEUE_ACCEPTED = 'datadog.tracer.queue.accepted'.freeze
+          METRIC_QUEUE_ACCEPTED_LENGTHS = 'datadog.tracer.queue.accepted_lengths'.freeze
+          METRIC_QUEUE_DROPPED = 'datadog.tracer.queue.dropped'.freeze
+          METRIC_QUEUE_LENGTH = 'datadog.tracer.queue.length'.freeze
+          METRIC_QUEUE_MAX_LENGTH = 'datadog.tracer.queue.max_length'.freeze
+          METRIC_QUEUE_SPANS = 'datadog.tracer.queue.spans'.freeze
+          METRIC_TRACES_FILTERED = 'datadog.tracer.traces.filtered'.freeze
+          METRIC_WRITER_CPU_TIME = 'datadog.tracer.writer.cpu_time'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/ext/runtime.rb

@@ -5,13 +5,7 @@ module Datadog
     module Runtime
       # Identity
       LANG = 'ruby'.freeze
-      LANG_INTERPRETER = begin
-        if Gem::Version.new(RUBY_VERSION) > Gem::Version.new('1.9')
-          (RUBY_ENGINE + '-' + RUBY_PLATFORM)
-        else
-          ('ruby-' + RUBY_PLATFORM)
-        end
-      end.freeze
+      LANG_INTERPRETER = (RUBY_ENGINE + '-' + RUBY_PLATFORM).freeze
       LANG_VERSION = RUBY_VERSION
       TRACER_VERSION = Datadog::VERSION::STRING
 

data/lib/ddtrace/metrics.rb

@@ -1,6 +1,7 @@
 require 'ddtrace/ext/metrics'
 
 require 'set'
+require 'logger'
 require 'ddtrace/utils/time'
 require 'ddtrace/runtime/identity'
 
@@ -54,8 +55,21 @@ module Datadog
       enabled? && !statsd.nil?
     end
 
-    def distribution(stat, value, options = nil)
+    def count(stat, value = nil, options = nil, &block)
+      return unless send_stats? && statsd.respond_to?(:count)
+      value, options = yield if block_given?
+      raise ArgumentError if value.nil?
+
+      statsd.count(stat, value, metric_options(options))
+    rescue StandardError => e
+      Datadog::Tracer.log.error("Failed to send count stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+    end
+
+    def distribution(stat, value = nil, options = nil, &block)
       return unless send_stats? && statsd.respond_to?(:distribution)
+      value, options = yield if block_given?
+      raise ArgumentError if value.nil?
+
       statsd.distribution(stat, value, metric_options(options))
     rescue StandardError => e
       Datadog::Tracer.log.error("Failed to send distribution stat. Cause: #{e.message} Source: #{e.backtrace.first}")
@@ -63,13 +77,18 @@ module Datadog
 
     def increment(stat, options = nil)
       return unless send_stats? && statsd.respond_to?(:increment)
+      options = yield if block_given?
+
       statsd.increment(stat, metric_options(options))
     rescue StandardError => e
       Datadog::Tracer.log.error("Failed to send increment stat. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
-    def gauge(stat, value, options = nil)
+    def gauge(stat, value = nil, options = nil, &block)
       return unless send_stats? && statsd.respond_to?(:gauge)
+      value, options = yield if block_given?
+      raise ArgumentError if value.nil?
+
       statsd.gauge(stat, value, metric_options(options))
     rescue StandardError => e
       Datadog::Tracer.log.error("Failed to send gauge stat. Cause: #{e.message} Source: #{e.backtrace.first}")
@@ -92,14 +111,25 @@ module Datadog
       end
     end
 
+    def send_metrics(metrics)
+      metrics.each { |m| send(m.type, *[m.name, m.value, m.options].compact) }
+    end
+
+    Metric = Struct.new(:type, :name, :value, :options) do
+      def initialize(*args)
+        super
+        self.options = options || {}
+      end
+    end
+
     # For defining and adding default options to metrics
     module Options
       DEFAULT = {
         tags: DEFAULT_TAGS = [
-          "#{Ext::Metrics::TAG_LANG}:#{Runtime::Identity.lang}".freeze
-          # "#{Ext::Metrics::TAG_LANG_INTERPRETER}:#{Runtime::Identity.lang_interpreter}".freeze,
-          # "#{Ext::Metrics::TAG_LANG_VERSION}:#{Runtime::Identity.lang_version}".freeze,
-          # "#{Ext::Metrics::TAG_TRACER_VERSION}:#{Runtime::Identity.tracer_version}".freeze
+          "#{Ext::Metrics::TAG_LANG}:#{Runtime::Identity.lang}".freeze,
+          "#{Ext::Metrics::TAG_LANG_INTERPRETER}:#{Runtime::Identity.lang_interpreter}".freeze,
+          "#{Ext::Metrics::TAG_LANG_VERSION}:#{Runtime::Identity.lang_version}".freeze,
+          "#{Ext::Metrics::TAG_TRACER_VERSION}:#{Runtime::Identity.tracer_version}".freeze
         ].freeze
       }.freeze
 
@@ -125,8 +155,61 @@ module Datadog
       end
     end
 
+    # For defining and adding helpers to metrics
+    module Helpers
+      [
+        :count,
+        :distribution,
+        :increment,
+        :gauge,
+        :time
+      ].each do |metric_type|
+        define_method(metric_type) do |name, stat|
+          name = name.to_sym
+          define_method(name) do |*args, &block|
+            send(metric_type, stat, *args, &block)
+          end
+        end
+      end
+    end
+
+    module Logging
+      # Surrogate for Datadog::Statsd to log elsewhere
+      class Adapter
+        attr_accessor :logger
+
+        def initialize(logger = nil)
+          @logger = logger || Logger.new(STDOUT).tap do |l|
+            l.level = Logger::INFO
+            l.progname = nil
+            l.formatter = proc do |_severity, datetime, _progname, msg|
+              stat = JSON.parse(msg[3..-1]) # Trim off leading progname...
+              "#{JSON.dump(timestamp: datetime.to_i, message: 'Metric sent.', metric: stat)}\n"
+            end
+          end
+        end
+
+        def count(stat, value, options = nil)
+          logger.info({ stat: stat, type: :count, value: value, options: options }.to_json)
+        end
+
+        def distribution(stat, value, options = nil)
+          logger.info({ stat: stat, type: :distribution, value: value, options: options }.to_json)
+        end
+
+        def increment(stat, options = nil)
+          logger.info({ stat: stat, type: :increment, options: options }.to_json)
+        end
+
+        def gauge(stat, value, options = nil)
+          logger.info({ stat: stat, type: :gauge, value: value, options: options }.to_json)
+        end
+      end
+    end
+
     # Make available on for both class and instance.
     include Options
     extend Options
+    extend Helpers
   end
 end

data/lib/ddtrace/propagation/http_propagator.rb

@@ -24,7 +24,7 @@ module Datadog
       end
 
       # Inject all configured propagation styles
-      ::Datadog.configuration.propagation_inject_style.each do |style|
+      ::Datadog.configuration.distributed_tracing.propagation_inject_style.each do |style|
         propagator = PROPAGATION_STYLES[style]
         propagator.inject!(context, env) unless propagator.nil?
       end
@@ -36,7 +36,7 @@ module Datadog
       context = nil
       dd_context = nil
 
-      ::Datadog.configuration.propagation_extract_style.each do |style|
+      ::Datadog.configuration.distributed_tracing.propagation_extract_style.each do |style|
         propagator = PROPAGATION_STYLES[style]
         next if propagator.nil?
 

data/lib/ddtrace/runtime/class_count.rb

@@ -5,12 +5,12 @@ module Datadog
       module_function
 
       def value
-        ObjectSpace.count_objects[:T_CLASS]
+        ::ObjectSpace.count_objects[:T_CLASS]
       end
 
       def available?
-        ObjectSpace.respond_to?(:count_objects) \
-          && ObjectSpace.count_objects.key?(:T_CLASS)
+        ::ObjectSpace.respond_to?(:count_objects) \
+          && ::ObjectSpace.count_objects.key?(:T_CLASS)
       end
     end
   end

data/lib/ddtrace/runtime/object_space.rb

@@ -0,0 +1,19 @@
+require 'objspace'
+
+module Datadog
+  module Runtime
+    # Retrieves garbage collection statistics
+    module ObjectSpace
+      module_function
+
+      def estimate_bytesize(object)
+        return 0 unless ::ObjectSpace.respond_to?(:memsize_of)
+
+        # Rough calculation of bytesize; not very accurate.
+        object.instance_variables.inject(::ObjectSpace.memsize_of(object)) do |sum, var|
+          sum + ::ObjectSpace.memsize_of(object.instance_variable_get(var))
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/span.rb

@@ -243,7 +243,7 @@ module Datadog
 
     private
 
-    if defined?(JRUBY_VERSION) || Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0.0')
+    if defined?(JRUBY_VERSION) || Gem::Version.new(RUBY_VERSION) < Gem::Version.new(VERSION::MINIMUM_RUBY_VERSION)
       def now_allocations
         0
       end

data/lib/ddtrace/tracer.rb

@@ -230,9 +230,10 @@ module Datadog
         # root span
         @sampler.sample!(span)
         span.set_tag('system.pid', Process.pid)
-        if ctx && ctx.trace_id && ctx.span_id
+
+        if ctx && ctx.trace_id
           span.trace_id = ctx.trace_id
-          span.parent_id = ctx.span_id
+          span.parent_id = ctx.span_id unless ctx.span_id.nil?
         end
       else
         # child span
@@ -391,8 +392,8 @@ module Datadog
       transport_options = options.fetch(:transport_options, {})
 
       # Compile writer options
-      rebuild_writer = false
-      writer_options = {}
+      writer_options = options.fetch(:writer_options, {})
+      rebuild_writer = !writer_options.empty?
 
       # Re-build the sampler and writer if priority sampling is enabled,
       # but neither are configured. Verify the sampler isn't already a

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

@@ -1,4 +1,4 @@
-require 'ddtrace/transport/statistics'
+require 'ddtrace/transport/http/statistics'
 require 'ddtrace/transport/http/env'
 
 module Datadog
@@ -6,7 +6,7 @@ module Datadog
     module HTTP
       # Routes, encodes, and sends tracer data to the trace agent via HTTP.
       class Client
-        include Transport::Statistics
+        include Transport::HTTP::Statistics
 
         attr_reader \
           :apis,
@@ -47,8 +47,7 @@ module Datadog
           end
 
           # Update statistics
-          stats.internal_error += 1
-          stats.consecutive_errors += 1
+          update_stats_from_exception!(e)
 
           InternalErrorResponse.new(e)
         end

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

@@ -16,6 +16,10 @@ module Datadog
         end
 
         def_delegators :@http_response, *Transport::Response.instance_methods
+
+        def code
+          @http_response.respond_to?(:code) ? @http_response.code : nil
+        end
       end
     end
   end

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

@@ -0,0 +1,30 @@
+require 'ddtrace/transport/statistics'
+
+module Datadog
+  module Transport
+    module HTTP
+      # Tracks statistics for HTTP transports
+      module Statistics
+        def self.included(base)
+          base.send(:include, Transport::Statistics)
+          base.send(:include, InstanceMethods)
+        end
+
+        # Instance methods for HTTP statistics
+        module InstanceMethods
+          # Decorate metrics for HTTP responses
+          def metrics_for_response(response)
+            super.tap do |metrics|
+              # 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}"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/statistics.rb

@@ -1,3 +1,5 @@
+require 'ddtrace/diagnostics/health'
+
 module Datadog
   module Transport
     # Tracks statistics for transports
@@ -16,6 +18,32 @@ module Datadog
           stats.internal_error += 1 if response.internal_error?
           stats.consecutive_errors += 1
         end
+
+        # Send health metrics
+        Diagnostics::Health.metrics.send_metrics(
+          metrics_for_response(response).values
+        )
+      end
+
+      def metrics_for_response(response)
+        {}.tap do |metrics|
+          metrics[:api_errors] = Metrics::Metric.new(:api_errors, nil, 1) if response.internal_error?
+          metrics[:api_responses] = Metrics::Metric.new(:api_responses, nil, 1) unless response.internal_error?
+        end
+      end
+
+      def update_stats_from_exception!(exception)
+        stats.internal_error += 1
+        stats.consecutive_errors += 1
+
+        # Send health metrics
+        Diagnostics::Health.metrics.send_metrics(
+          metrics_for_exception(exception).values
+        )
+      end
+
+      def metrics_for_exception(_exception)
+        { api_errors: Metrics::Metric.new(:api_errors, nil, 1) }
       end
 
       # Stat counts

data/lib/ddtrace/version.rb

@@ -1,10 +1,12 @@
 module Datadog
   module VERSION
     MAJOR = 0
-    MINOR = 28
+    MINOR = 29
     PATCH = 0
     PRE = nil
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+
+    MINIMUM_RUBY_VERSION = '2.0.0'.freeze
   end
 end

data/lib/ddtrace/workers.rb

@@ -10,6 +10,8 @@ module Datadog
     # will perform a task at regular intervals. The thread can be stopped
     # with the +stop()+ method and can start with the +start()+ method.
     class AsyncTransport
+      DEFAULT_BUFFER_MAX_SIZE = 1000
+      DEFAULT_FLUSH_INTERVAL = 1
       DEFAULT_TIMEOUT = 5
       BACK_OFF_RATIO = 1.2
       BACK_OFF_MAX = 5
@@ -26,12 +28,12 @@ module Datadog
         @runtime_metrics_task = options[:on_runtime_metrics]
 
         # Intervals
-        interval = options.fetch(:interval, 1)
+        interval = options.fetch(:interval, DEFAULT_FLUSH_INTERVAL)
         @flush_interval = interval
         @back_off = interval
 
         # Buffers
-        buffer_size = options.fetch(:buffer_size, 100)
+        buffer_size = options.fetch(:buffer_size, DEFAULT_BUFFER_MAX_SIZE)
         @trace_buffer = TraceBuffer.new(buffer_size)
 
         # Threading