ddtrace 0.34.1 → 0.36.0

data/lib/ddtrace/contrib/sinatra/tracer_middleware.rb

@@ -19,23 +19,22 @@ module Datadog
             tracer.provider.context = context if context.trace_id
           end
 
-          # Begin the trace
-          tracer.trace(
-            Ext::SPAN_REQUEST,
-            service: configuration[:service_name],
-            span_type: Datadog::Ext::HTTP::TYPE_INBOUND
-          ) do |span|
-            Sinatra::Env.set_datadog_span(env, span)
+          Sinatra::Env.set_middleware_start_time(env)
 
+          # Run application stack
+          response = @app.call(env)
+        ensure
+          # Augment current Sinatra middleware span if we are the top-most Sinatra app on the Rack stack.
+          span = Sinatra::Env.datadog_span(env)
+          if span
             Sinatra::Env.request_header_tags(env, configuration[:headers][:request]).each do |name, value|
               span.set_tag(name, value) if span.get_tag(name).nil?
             end
 
-            # Run application stack
-            status, headers, response_body = @app.call(env)
-
-            Sinatra::Headers.response_header_tags(headers, configuration[:headers][:response]).each do |name, value|
-              span.set_tag(name, value) if span.get_tag(name).nil?
+            if response && (headers = response[1])
+              Sinatra::Headers.response_header_tags(headers, configuration[:headers][:response]).each do |name, value|
+                span.set_tag(name, value) if span.get_tag(name).nil?
+              end
             end
 
             # Set analytics sample rate
@@ -44,7 +43,11 @@ module Datadog
             # Measure service stats
             Contrib::Analytics.set_measured(span)
 
-            [status, headers, response_body]
+            span.finish
+
+            # Remove span from env, so other Sinatra apps mounted on this same
+            # Rack stack do not modify it with their own information.
+            Sinatra::Env.set_datadog_span(env, nil)
           end
         end
 

data/lib/ddtrace/correlation.rb

@@ -6,21 +6,24 @@ module Datadog
   # e.g. Retrieve a correlation to the current trace for logging, etc.
   module Correlation
     # Struct representing correlation
-    Identifier = Struct.new(:trace_id, :span_id, :env, :version) do
+    Identifier = Struct.new(:trace_id, :span_id, :env, :service, :version) do
       def initialize(*args)
         super
         self.trace_id = trace_id || 0
         self.span_id = span_id || 0
         self.env = env || Datadog.configuration.env
+        self.service = service || Datadog.configuration.service
         self.version = version || Datadog.configuration.version
       end
 
       def to_s
-        str =  "#{Ext::Correlation::ATTR_TRACE_ID}=#{trace_id}"
-        str += " #{Ext::Correlation::ATTR_SPAN_ID}=#{span_id}"
-        str += " #{Ext::Correlation::ATTR_ENV}=#{env}"
-        str += " #{Ext::Correlation::ATTR_VERSION}=#{version}"
-        str
+        attributes = []
+        attributes << "#{Ext::Correlation::ATTR_ENV}=#{env}" unless env.nil?
+        attributes << "#{Ext::Correlation::ATTR_SERVICE}=#{service}" unless service.nil?
+        attributes << "#{Ext::Correlation::ATTR_VERSION}=#{version}" unless version.nil?
+        attributes << "#{Ext::Correlation::ATTR_TRACE_ID}=#{trace_id}"
+        attributes << "#{Ext::Correlation::ATTR_SPAN_ID}=#{span_id}"
+        attributes.join(' ')
       end
     end.freeze
 

data/lib/ddtrace/diagnostics/health.rb

@@ -19,6 +19,8 @@ module Datadog
         count :queue_accepted_lengths, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_ACCEPTED_LENGTHS
         count :queue_dropped, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_DROPPED
         count :traces_filtered, Ext::Diagnostics::Health::Metrics::METRIC_TRACES_FILTERED
+        count :transport_trace_too_large, Ext::Diagnostics::Health::Metrics::METRIC_TRANSPORT_TRACE_TOO_LARGE
+        count :transport_chunked, Ext::Diagnostics::Health::Metrics::METRIC_TRANSPORT_CHUNKED
         count :writer_cpu_time, Ext::Diagnostics::Health::Metrics::METRIC_WRITER_CPU_TIME
 
         gauge :queue_length, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_LENGTH
@@ -26,12 +28,6 @@ module Datadog
         gauge :queue_spans, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_SPANS
         gauge :sampling_service_cache_length, Ext::Diagnostics::Health::Metrics::METRIC_SAMPLING_SERVICE_CACHE_LENGTH
       end
-
-      module_function
-
-      def metrics
-        Datadog.configuration.diagnostics.health_metrics
-      end
     end
   end
 end

data/lib/ddtrace/encoding.rb

@@ -10,19 +10,12 @@ module Datadog
         raise NotImplementedError
       end
 
-      # Encodes a list of traces, expecting a list of items where each items
-      # is a list of spans. Before dump the string in a serialized format all
-      # traces are normalized. The traces nesting is not changed.
-      def encode_traces(traces)
-        to_send = []
-        traces.each do |trace|
-          to_send << trace.map(&:to_hash)
-        end
-        encode(to_send)
+      # Concatenates a list of elements previously encoded by +#encode+.
+      def join(encoded_elements)
+        raise NotImplementedError
       end
 
-      # Defines the underlying format used during traces or services encoding.
-      # This method must be implemented and should only be used by the internal functions.
+      # Serializes a single trace into a String suitable for network transmission.
       def encode(_)
         raise NotImplementedError
       end
@@ -44,34 +37,8 @@ module Datadog
         JSON.dump(obj)
       end
 
-      # New version of JSON Encoder that is API compliant.
-      module V2
-        extend JSONEncoder
-
-        ENCODED_IDS = [
-          :trace_id,
-          :span_id,
-          :parent_id
-        ].freeze
-
-        module_function
-
-        def encode_traces(traces)
-          trace_hashes = traces.collect do |trace|
-            # Convert each trace to hash
-            trace.map(&:to_hash).tap do |spans|
-              # Convert IDs to hexadecimal
-              spans.each do |span|
-                ENCODED_IDS.each do |id|
-                  span[id] = span[id].to_s(16) if span.key?(id)
-                end
-              end
-            end
-          end
-
-          # Wrap traces & encode them
-          encode(traces: trace_hashes)
-        end
+      def join(encoded_data)
+        "[#{encoded_data.join(',')}]"
       end
     end
 
@@ -90,6 +57,13 @@ module Datadog
       def encode(obj)
         MessagePack.pack(obj)
       end
+
+      def join(encoded_data)
+        packer = MessagePack::Packer.new
+        packer.write_array_header(encoded_data.size)
+
+        (packer.buffer.to_a + encoded_data).join
+      end
     end
   end
 end

data/lib/ddtrace/event.rb

@@ -41,7 +41,7 @@ module Datadog
           begin
             block.call(*args)
           rescue StandardError => e
-            Datadog::Logger.log.debug("Error while handling '#{key}' for '#{name}' event: #{e.message}")
+            Datadog.logger.debug("Error while handling '#{key}' for '#{name}' event: #{e.message}")
           end
         end
 

data/lib/ddtrace/ext/correlation.rb

@@ -2,6 +2,7 @@ module Datadog
   module Ext
     module Correlation
       ATTR_ENV = 'dd.env'.freeze
+      ATTR_SERVICE = 'dd.service'.freeze
       ATTR_SPAN_ID = 'dd.span_id'.freeze
       ATTR_TRACE_ID = 'dd.trace_id'.freeze
       ATTR_VERSION = 'dd.version'.freeze

data/lib/ddtrace/ext/diagnostics.rb

@@ -23,6 +23,8 @@ module Datadog
           METRIC_QUEUE_SPANS = 'datadog.tracer.queue.spans'.freeze
           METRIC_SAMPLING_SERVICE_CACHE_LENGTH = 'datadog.tracer.sampling.service_cache_length'.freeze
           METRIC_TRACES_FILTERED = 'datadog.tracer.traces.filtered'.freeze
+          METRIC_TRANSPORT_CHUNKED = 'datadog.tracer.transport.chunked'.freeze
+          METRIC_TRANSPORT_TRACE_TOO_LARGE = 'datadog.tracer.transport.trace_too_large'.freeze
           METRIC_WRITER_CPU_TIME = 'datadog.tracer.writer.cpu_time'.freeze
         end
       end

data/lib/ddtrace/ext/environment.rb

@@ -7,6 +7,7 @@ module Datadog
       ENV_VERSION = 'DD_VERSION'.freeze
 
       TAG_ENV = 'env'.freeze
+      TAG_SERVICE = 'service'.freeze
       TAG_VERSION = 'version'.freeze
     end
   end

data/lib/ddtrace/ext/forced_tracing.rb

@@ -12,7 +12,7 @@ module Datadog
 
         # Only log each deprecation warning once (safeguard against log spam)
         unless @deprecation_warning_shown
-          Datadog::Logger.log.warn(
+          Datadog.logger.warn(
             'forced tracing: Datadog::Ext::ForcedTracing has been renamed to Datadog::Ext::ManualTracing'
           )
           @deprecation_warning_shown = true

data/lib/ddtrace/logger.rb

@@ -1,57 +1,16 @@
 require 'logger'
 
 module Datadog
-  LOG_PREFIX = 'ddtrace'.freeze
-
   # A custom logger with minor enhancements:
   # - progname defaults to ddtrace to clearly identify Datadog dd-trace-rb related messages
   # - adds last caller stack-trace info to know where the message comes from
   class Logger < ::Logger
-    # Global, memoized, lazy initialized instance of a logger that is used within the the Datadog
-    # namespace. This logger outputs to +STDOUT+ by default, and is considered thread-safe.
-    class << self
-      def log
-        unless defined? @logger
-          @logger = Datadog::Logger.new(STDOUT)
-          @logger.level = Logger::WARN
-        end
-        @logger
-      end
-
-      # Override the default logger with a custom one.
-      def log=(logger)
-        return unless logger
-        return unless logger.respond_to? :methods
-        return unless logger.respond_to? :error
-        if logger.respond_to? :methods
-          unimplemented = new(STDOUT).methods - logger.methods
-          unless unimplemented.empty?
-            logger.error("logger #{logger} does not implement #{unimplemented}")
-            return
-          end
-        end
-        @logger = logger
-      end
-
-      # Activate the debug mode providing more information related to tracer usage
-      # Default to Warn level unless using custom logger
-      def debug_logging=(value)
-        if value
-          log.level = Logger::DEBUG
-        elsif log.is_a?(Datadog::Logger)
-          log.level = Logger::WARN
-        end
-      end
-
-      # Return if the debug mode is activated or not
-      def debug_logging
-        log.level == Logger::DEBUG
-      end
-    end
+    PREFIX = 'ddtrace'.freeze
 
     def initialize(*args, &block)
       super
-      self.progname = LOG_PREFIX
+      self.progname = PREFIX
+      self.level = ::Logger::WARN
     end
 
     def add(severity, message = nil, progname = nil, &block)

data/lib/ddtrace/metrics.rb

@@ -63,7 +63,7 @@ module Datadog
 
       statsd.count(stat, value, metric_options(options))
     rescue StandardError => e
-      Datadog::Logger.log.error("Failed to send count stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.error("Failed to send count stat. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def distribution(stat, value = nil, options = nil, &block)
@@ -73,7 +73,7 @@ module Datadog
 
       statsd.distribution(stat, value, metric_options(options))
     rescue StandardError => e
-      Datadog::Logger.log.error("Failed to send distribution stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.error("Failed to send distribution stat. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def increment(stat, options = nil)
@@ -82,7 +82,7 @@ module Datadog
 
       statsd.increment(stat, metric_options(options))
     rescue StandardError => e
-      Datadog::Logger.log.error("Failed to send increment stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.error("Failed to send increment stat. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def gauge(stat, value = nil, options = nil, &block)
@@ -92,7 +92,7 @@ module Datadog
 
       statsd.gauge(stat, value, metric_options(options))
     rescue StandardError => e
-      Datadog::Logger.log.error("Failed to send gauge stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.error("Failed to send gauge stat. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def time(stat, options = nil)
@@ -108,7 +108,7 @@ module Datadog
           distribution(stat, ((finished - start) * 1000), options)
         end
       rescue StandardError => e
-        Datadog::Logger.log.error("Failed to send time stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+        Datadog.logger.error("Failed to send time stat. Cause: #{e.message} Source: #{e.backtrace.first}")
       end
     end
 

data/lib/ddtrace/monkey.rb

@@ -48,7 +48,7 @@ module Datadog
     end
 
     def log_deprecation_warning(method)
-      Datadog::Logger.log.warn("#{method}:#{DEPRECATION_WARNING}")
+      Datadog.logger.warn("#{method}:#{DEPRECATION_WARNING}")
     end
 
     class << self

data/lib/ddtrace/opentracer/global_tracer.rb

@@ -6,7 +6,7 @@ module Datadog
         super.tap do
           if tracer.class <= Datadog::OpenTracer::Tracer
             # Update the Datadog global tracer, too.
-            Datadog.configuration.tracer = tracer.datadog_tracer
+            Datadog.configure { |c| c.tracer = tracer.datadog_tracer }
           end
         end
       end

data/lib/ddtrace/pin.rb

@@ -12,26 +12,34 @@ module Datadog
       obj.datadog_pin
     end
 
-    attr_reader :service_name
     attr_accessor :app
-    attr_accessor :tags
     attr_accessor :app_type
-    attr_accessor :name
-    attr_accessor :tracer
     attr_accessor :config
+    attr_accessor :name
+    attr_accessor :service_name
+    attr_accessor :tags
+    attr_writer :tracer
+    attr_accessor :writer
+
+    alias service= service_name=
+    alias service service_name
 
     def initialize(service_name, options = {})
       @app = options[:app]
-      @tags = options[:tags]
       @app_type = options[:app_type]
-      @name = nil # this would rarely be overriden as it's really span-specific
-      @tracer = options[:tracer] || Datadog.tracer
       @config = options[:config]
-      self.service_name = service_name
+      @name = nil # this would rarely be overriden as it's really span-specific
+      @service_name = service_name
+      @tags = options[:tags]
+      @tracer = options[:tracer]
+    end
+
+    def tracer
+      @tracer || Datadog.tracer
     end
 
     def enabled?
-      return @tracer.enabled if @tracer
+      return tracer.enabled if tracer
       false
     end
 
@@ -56,13 +64,6 @@ module Datadog
       obj.datadog_pin = self
     end
 
-    def service_name=(name)
-      @service_name = name
-    end
-
-    alias service= service_name=
-    alias service service_name
-
     def to_s
       "Pin(service:#{service},app:#{app},app_type:#{app_type},name:#{name})"
     end
@@ -107,7 +108,7 @@ module Datadog
     def log_deprecation_warning(method_name)
       # Only log each deprecation warning once (safeguard against log spam)
       do_once(method_name) do
-        Datadog::Logger.log.warn("#{method_name}:#{DEPRECATION_WARNING}")
+        Datadog.logger.warn("#{method_name}:#{DEPRECATION_WARNING}")
       end
     end
   end

data/lib/ddtrace/pipeline.rb

@@ -34,7 +34,7 @@ module Datadog
 
       result || []
     rescue => e
-      Datadog::Logger.log.debug(
+      Datadog.logger.debug(
         "trace dropped entirely due to `Pipeline.before_flush` error: #{e}"
       )
 

data/lib/ddtrace/propagation/http_propagator.rb

@@ -19,7 +19,7 @@ module Datadog
     def self.inject!(context, env)
       # Prevent propagation from being attempted if context provided is nil.
       if context.nil?
-        ::Datadog::Logger.log.debug('Cannot inject context into env to propagate over HTTP: context is nil.'.freeze)
+        ::Datadog.logger.debug('Cannot inject context into env to propagate over HTTP: context is nil.'.freeze)
         return
       end
 
@@ -58,7 +58,7 @@ module Datadog
             # Return an empty/new context if we have a mismatch in values extracted
             msg = "#{context.trace_id} != #{extracted_context.trace_id} && " \
                   "#{context.span_id} != #{extracted_context.span_id}"
-            ::Datadog::Logger.log.debug("Cannot extract context from HTTP: extracted contexts differ, #{msg}".freeze)
+            ::Datadog.logger.debug("Cannot extract context from HTTP: extracted contexts differ, #{msg}".freeze)
             # DEV: This will return from `self.extract` not this `each` block
             return ::Datadog::Context.new
           end

data/lib/ddtrace/runtime/cgroup.rb

@@ -27,7 +27,7 @@ module Datadog
               end
             end
           rescue StandardError => e
-            Datadog::Logger.log.error("Error while parsing cgroup. Cause: #{e.message} Location: #{e.backtrace.first}")
+            Datadog.logger.error("Error while parsing cgroup. Cause: #{e.message} Location: #{e.backtrace.first}")
           end
         end
       end