ddtrace 0.7.2 → 0.8.0

data/lib/ddtrace/contrib/rails/active_record.rb

@@ -46,7 +46,7 @@ module Datadog
           span.set_tag('rails.db.vendor', adapter_name)
           span.set_tag('rails.db.cached', cached) if cached
           span.start_time = start
-          span.finish_at(finish)
+          span.finish(finish)
         rescue StandardError => e
           Datadog::Tracer.log.error(e.message)
         end

data/lib/ddtrace/contrib/rails/active_support.rb

@@ -8,7 +8,7 @@ module Datadog
       module ActiveSupport
         def self.instrument
           # patch Rails core components
-          Datadog::RailsPatcher.patch_cache_store()
+          Datadog::RailsCachePatcher.patch_cache_store()
 
           # subscribe when a cache read starts being processed
           ::ActiveSupport::Notifications.subscribe('start_cache_read.active_support') do |*args|
@@ -106,7 +106,7 @@ module Datadog
             end
           ensure
             span.start_time = start
-            span.finish_at(finish)
+            span.finish(finish)
           end
         rescue StandardError => e
           Datadog::Tracer.log.error(e.message)

data/lib/ddtrace/contrib/rails/core_extensions.rb

@@ -1,6 +1,6 @@
 module Datadog
-  # RailsPatcher contains function to patch the Rails libraries.
-  module RailsPatcher
+  # RailsRendererPatcher contains function to patch Rails rendering libraries.
+  module RailsRendererPatcher
     module_function
 
     def patch_renderer
@@ -8,33 +8,58 @@ module Datadog
       patch_renderer_render_partial
     end
 
-    def patch_cache_store
-      patch_cache_store_read
-      patch_cache_store_fetch
-      patch_cache_store_write
-      patch_cache_store_delete
-      patch_cache_store_instrument
-    end
-
     def patch_renderer_render_template
-      ::ActionView::Renderer.class_eval do
-        alias_method :render_template_without_datadog, :render_template
-        def render_template(*args, &block)
-          ActiveSupport::Notifications.instrument('start_render_template.action_view')
-          render_template_without_datadog(*args, &block)
+      if defined?(::ActionView::Renderer)
+        ::ActionView::Renderer.class_eval do
+          alias_method :render_template_without_datadog, :render_template
+          def render_template(*args, &block)
+            ActiveSupport::Notifications.instrument('start_render_template.action_view')
+            render_template_without_datadog(*args, &block)
+          end
+        end
+      else # Rails < 3.1
+        ::ActionView::Template.class_eval do
+          alias_method :render_template_without_datadog, :render
+          def render(*args, &block)
+            ActiveSupport::Notifications.instrument('start_render_template.action_view')
+            render_template_without_datadog(*args, &block)
+          end
         end
       end
     end
 
     def patch_renderer_render_partial
-      ::ActionView::PartialRenderer.class_eval do
-        alias_method :render_partial_without_datadog, :render_partial
-        def render_partial(*args, &block)
-          ActiveSupport::Notifications.instrument('start_render_partial.action_view')
-          render_partial_without_datadog(*args, &block)
+      if defined?(::ActionView::PartialRenderer)
+        ::ActionView::PartialRenderer.class_eval do
+          alias_method :render_partial_without_datadog, :render_partial
+          def render_partial(*args, &block)
+            ActiveSupport::Notifications.instrument('start_render_partial.action_view')
+            render_partial_without_datadog(*args, &block)
+          end
+        end
+      else # Rails < 3.1
+        ::ActionView::Partials::PartialRenderer.class_eval do
+          alias_method :render_partial_without_datadog, :render
+          def render(*args, &block)
+            ActiveSupport::Notifications.instrument('start_render_partial.action_view')
+            render_partial_without_datadog(*args, &block)
+          end
         end
       end
     end
+  end
+
+  # RailsCachePatcher contains function to patch Rails caching libraries.
+  module RailsCachePatcher
+    module_function
+
+    def patch_cache_store
+      patch_cache_store_read
+      patch_cache_store_fetch
+      patch_cache_store_write
+      patch_cache_store_delete
+      patch_cache_store_instrument
+    end
 
     def cache_store_class(k)
       # When Redis is used, we can't only patch Cache::Store as it is

data/lib/ddtrace/contrib/rails/framework.rb

@@ -11,6 +11,17 @@ require 'ddtrace/contrib/rails/active_record'
 require 'ddtrace/contrib/rails/active_support'
 require 'ddtrace/contrib/rails/utils'
 
+# Rails < 3.1
+unless defined?(ActiveRecord::Base.connection_config)
+  ActiveRecord::Base.class_eval do
+    class << self
+      def connection_config
+        connection_pool.spec.config
+      end
+    end
+  end
+end
+
 module Datadog
   module Contrib
     # TODO[manu]: write docs

data/lib/ddtrace/distributed.rb

@@ -0,0 +1,38 @@
+require 'ddtrace/span'
+
+module Datadog
+  # Common code related to distributed tracing.
+  module Distributed
+    module_function
+
+    # Parses a trace_id and a parent_id, typically sent as headers in
+    # a distributed tracing context, and returns a couple of trace_id,parent_id
+    # which are garanteed to be both non-zero. This does not 100% ensure they
+    # are valid (after all, the caller could mess up data) but at least it
+    # sorts out most common errors, such as syntax, nil values, etc.
+    # Both headers must be set, else nil values are returned, for both.
+    # Reports problem on debug log.
+    def parse_trace_headers(trace_id_header, parent_id_header)
+      return nil, nil if trace_id_header.nil? || parent_id_header.nil?
+      trace_id = trace_id_header.to_i
+      parent_id = parent_id_header.to_i
+      if trace_id.zero?
+        Datadog::Tracer.log.debug("invalid trace_id header: #{trace_id_header}")
+        return nil, nil
+      end
+      if parent_id.zero?
+        Datadog::Tracer.log.debug("invalid parent_id header: #{parent_id_header}")
+        return nil, nil
+      end
+      if trace_id < 0 || trace_id >= Datadog::Span::MAX_ID
+        Datadog::Tracer.log.debug("trace_id out of range: #{trace_id_header}")
+        return nil, nil
+      end
+      if parent_id < 0 || parent_id >= Datadog::Span::MAX_ID
+        Datadog::Tracer.log.debug("parent_id out of range: #{parent_id_header}")
+        return nil, nil
+      end
+      [trace_id, parent_id]
+    end
+  end
+end

data/lib/ddtrace/ext/distributed.rb

@@ -0,0 +1,10 @@
+module Datadog
+  module Ext
+    module DistributedTracing
+      # HTTP headers one should set for distributed tracing.
+      # These are cross-language (eg: Python, Go and other implementations should honor these)
+      HTTP_HEADER_TRACE_ID = 'x-datadog-trace-id'.freeze
+      HTTP_HEADER_PARENT_ID = 'x-datadog-parent-id'.freeze
+    end
+  end
+end

data/lib/ddtrace/pin.rb

@@ -16,15 +16,17 @@ module Datadog
     attr_accessor :app_type
     attr_accessor :name
     attr_accessor :tracer
+    attr_accessor :config
 
     # [ruby19] named parameters would be more idiomatic here, but would break backward compatibility
-    def initialize(service, options = { app: nil, tags: nil, app_type: nil, tracer: nil })
+    def initialize(service, options = { app: nil, tags: nil, app_type: nil, tracer: nil, config: nil })
       @service = service
-      @app = options[:app]
-      @tags = options[:tags]
-      @app_type = options[:app_type]
+      @app = options.fetch(:app, nil)
+      @tags = options.fetch(:tags, nil)
+      @app_type = options.fetch(:app_type, nil)
       @name = nil # this would rarely be overriden as it's really span-specific
       @tracer = options[:tracer] || Datadog.tracer
+      @config = options.fetch(:config, nil)
     end
 
     def enabled?

data/lib/ddtrace/provider.rb

@@ -0,0 +1,16 @@
+module Datadog
+  # DefaultContextProvider is a default context provider that retrieves
+  # all contexts from the current thread-local storage. It is suitable for
+  # synchronous programming.
+  class DefaultContextProvider
+    # Initializes the default context provider with a thread-bound context.
+    def initialize
+      @context = Datadog::ThreadLocalContext.new
+    end
+
+    # Return the current context.
+    def context
+      @context.local
+    end
+  end
+end

data/lib/ddtrace/span.rb

@@ -1,4 +1,5 @@
 require 'time'
+require 'thread'
 
 require 'ddtrace/utils'
 require 'ddtrace/ext/errors'
@@ -10,23 +11,30 @@ module Datadog
   # within a larger operation. Spans can be nested within each other, and in those instances
   # will have a parent-child relationship.
   class Span
-    # The max value for a \Span identifier
-    MAX_ID = 2**64 - 1
+    # The max value for a \Span identifier.
+    # Span and trace identifiers should be strictly positive and strictly inferior to this limit.
+    #
+    # Limited to 63-bit positive integers, as some other languages might be limited to this,
+    # and IDs need to be easy to port across various languages and platforms.
+    MAX_ID = 2**63
 
     attr_accessor :name, :service, :resource, :span_type,
                   :start_time, :end_time,
                   :span_id, :trace_id, :parent_id,
-                  :status, :parent, :sampled
+                  :status, :sampled,
+                  :tracer, :context
+
+    attr_reader :parent
 
-    # Create a new span linked to the given tracer. Call the <tt>finish()</tt> method once the
-    # tracer operation is over or use the <tt>finish_at(time)</tt> helper to close the span with the
-    # given +time+. Available options are:
+    # Create a new span linked to the given tracer. Call the \Tracer method <tt>start_span()</tt>
+    # and then <tt>finish()</tt> once the tracer operation is over.
     #
     # * +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)
     # * +parent_id+: the identifier of the parent span
     # * +trace_id+: the identifier of the root span for this trace
+    # * +context+: the context of the span
     def initialize(tracer, name, options = {})
       @tracer = tracer
 
@@ -35,9 +43,11 @@ module Datadog
       @resource = options.fetch(:resource, name)
       @span_type = options.fetch(:span_type, nil)
 
-      @span_id = Datadog::Utils.next_id()
+      @span_id = Datadog::Utils.next_id
       @parent_id = options.fetch(:parent_id, 0)
-      @trace_id = options.fetch(:trace_id, @span_id)
+      @trace_id = options.fetch(:trace_id, Datadog::Utils.next_id)
+
+      @context = options.fetch(:context, nil)
 
       @meta = {}
       @metrics = {}
@@ -46,8 +56,8 @@ module Datadog
       @parent = nil
       @sampled = true
 
-      @start_time = Time.now.utc
-      @end_time = nil
+      @start_time = nil # set by Tracer.start_span
+      @end_time = nil # set by Span.finish
     end
 
     # Set the given key / value tag pair on the span. Keys and values
@@ -65,8 +75,8 @@ module Datadog
       @meta[key]
     end
 
-    # Set the given key / value metric pair on the span. Keys must be string.
-    # Values must be floating point numbers.
+    # This method sets a tag with a floating point value for the given key. It acts
+    # like `set_tag()` and it simply add a tag without further processing.
     def set_metric(key, value)
       # enforce that the value is a floating point number
       value = Float(value)
@@ -91,18 +101,34 @@ module Datadog
 
     # Mark the span finished at the current time and submit it.
     def finish(finish_time = nil)
+      # A span should not be finished twice. Note that this is not thread-safe,
+      # finish is called from multiple threads, a given span might be finished
+      # several times. Again, one should not do this, so this test is more a
+      # fallback to avoid very bad things and protect you in most common cases.
       return if finished?
 
-      @end_time = finish_time.nil? ? Time.now.utc : finish_time
-      @tracer.record(self) unless @tracer.nil?
-      self
-    end
+      # Provide a default start_time if unset, but this should have been set by start_span.
+      # Using now here causes 0-duration spans, still, this is expected, as we never
+      # explicitely say when it started.
+      @start_time ||= Time.now.utc
+
+      @end_time = finish_time.nil? ? Time.now.utc : finish_time # finish this
+
+      # Finish does not really do anything if the span is not bound to a tracer and a context.
+      return self if @tracer.nil? || @context.nil?
 
-    # Proxy function that flag a span as finished with the given
-    # timestamp. This function is used for retro-compatibility.
-    # DEPRECATED: remove this function in the next release
-    def finish_at(finish_time)
-      finish(finish_time)
+      # spans without a service would be dropped, so here we provide a default.
+      # This should really never happen with integrations in contrib, as a default
+      # service is always set. It's only for custom instrumentation.
+      @service ||= @tracer.default_service unless @tracer.nil?
+
+      begin
+        @context.close_span(self)
+        @tracer.record(self)
+      rescue StandardError => e
+        Datadog::Tracer.log.debug("error recording finished trace: #{e}")
+      end
+      self
     end
 
     # Return whether the span is finished or not.
@@ -115,9 +141,14 @@ module Datadog
       "Span(name:#{@name},sid:#{@span_id},tid:#{@trace_id},pid:#{@parent_id})"
     end
 
+    # DEPRECATED: remove this function in the next release, replaced by ``parent=``
+    def set_parent(parent)
+      self.parent = parent
+    end
+
     # Set this span's parent, inheriting any properties not explicitly set.
     # If the parent is nil, set the span zero values.
-    def set_parent(parent)
+    def parent=(parent)
       @parent = parent
 
       if parent.nil?
@@ -127,6 +158,7 @@ module Datadog
         @trace_id = parent.trace_id
         @parent_id = parent.span_id
         @service ||= parent.service
+        @sampled = parent.sampled
       end
     end
 

data/lib/ddtrace/tracer.rb

@@ -4,7 +4,8 @@ require 'logger'
 require 'pathname'
 
 require 'ddtrace/span'
-require 'ddtrace/buffer'
+require 'ddtrace/context'
+require 'ddtrace/provider'
 require 'ddtrace/logger'
 require 'ddtrace/writer'
 require 'ddtrace/sampler'
@@ -15,6 +16,7 @@ module Datadog
   # example, a trace can be used to track the entire time spent processing a complicated web request.
   # Even though the request may require multiple resources and machines to handle the request, all
   # of these function calls and sub-requests would be encapsulated within a single trace.
+  # rubocop:disable Metrics/ClassLength
   class Tracer
     attr_reader :writer, :sampler, :services, :tags
     attr_accessor :enabled
@@ -55,6 +57,16 @@ module Datadog
       log.level == Logger::DEBUG
     end
 
+    # Return the current active \Context for this traced execution. This method is
+    # automatically called when calling Tracer.trace or Tracer.start_span,
+    # but it can be used in the application code during manual instrumentation.
+    #
+    # This method makes use of a \ContextProvider that is automatically set during the tracer
+    # initialization, or while using a library instrumentation.
+    def call_context
+      @provider.context
+    end
+
     # Initialize a new \Tracer used to create, sample and submit spans that measure the
     # time of sections of code. Available +options+ are:
     #
@@ -65,10 +77,10 @@ module Datadog
       @writer = options.fetch(:writer, Datadog::Writer.new)
       @sampler = options.fetch(:sampler, Datadog::AllSampler.new)
 
-      @buffer = Datadog::SpanBuffer.new()
+      @provider = options.fetch(:context_provider, Datadog::DefaultContextProvider.new)
+      @provider ||= Datadog::DefaultContextProvider.new # @provider should never be nil
 
       @mutex = Mutex.new
-      @spans = []
       @services = {}
       @tags = {}
     end
@@ -113,10 +125,10 @@ module Datadog
     # for non-root spans which have a parent. However, root spans without
     # a service would be invalid and rejected.
     def default_service
-      return @default_service if @default_service
+      return @default_service if instance_variable_defined?(:@default_service) && @default_service
       begin
         @default_service = File.basename($PROGRAM_NAME, '.*')
-      rescue => e
+      rescue StandardError => e
         Datadog::Tracer.log.error("unable to guess default service: #{e}")
         @default_service = 'ruby'.freeze
       end
@@ -132,6 +144,69 @@ module Datadog
       @tags.update(tags)
     end
 
+    # Guess context and parent from child_of entry.
+    def guess_context_and_parent(options = {})
+      child_of = options.fetch(:child_of, nil) # can be context or span
+
+      ctx = nil
+      parent = nil
+      unless child_of.nil?
+        if child_of.respond_to?(:current_span)
+          ctx = child_of
+          parent = child_of.current_span
+        elsif child_of.is_a?(Datadog::Span)
+          parent = child_of
+          ctx = child_of.context
+        end
+      end
+
+      ctx ||= call_context
+
+      [ctx, parent]
+    end
+
+    # Return a span that will trace an operation called \name. This method allows
+    # parenting passing \child_of as an option. If it's missing, the newly created span is a
+    # root span. Available options are:
+    #
+    # * +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.
+    # * +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)
+      tags = options.fetch(:tags, {})
+
+      opts = options.select do |k, _v|
+        # Filter options, we want no side effects with unexpected args.
+        # Plus, this documents the code (Ruby 2 named args would be better but we're Ruby 1.9 compatible)
+        [:service, :resource, :span_type].include?(k)
+      end
+
+      ctx, parent = guess_context_and_parent(options)
+      opts[:context] = ctx unless ctx.nil?
+
+      span = Span.new(self, name, opts)
+      if parent.nil?
+        # root span
+        @sampler.sample(span)
+        span.set_tag('system.pid', Process.pid)
+      else
+        # 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
+
+      # this could at some point be optional (start_active_span vs start_manual_span)
+      ctx.add_span(span) unless ctx.nil?
+
+      span
+    end
+
     # Return a +span+ that will trace an operation called +name+. You could trace your code
     # using a <tt>do-block</tt> like:
     #
@@ -160,22 +235,20 @@ module Datadog
     #   parent2 = tracer.trace('parent2')   # has no parent span
     #   parent2.finish()
     #
+    # Available options are:
+    #
+    # * +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)
+    # * +tags+: extra tags which should be added to the span.
     def trace(name, options = {})
-      span = Span.new(self, name, options)
-
-      # set up inheritance
-      parent = @buffer.get()
-      span.set_parent(parent)
-      @buffer.set(span)
-
-      @tags.each { |k, v| span.set_tag(k, v) } unless @tags.empty?
-
-      # sampling
-      if parent.nil?
-        @sampler.sample(span)
-      else
-        span.sampled = span.parent.sampled
+      opts = options.select do |k, _v|
+        # Filter options, we want no side effects with unexpected args.
+        # Plus, this documents the code (Ruby 2 named args would be better but we're Ruby 1.9 compatible)
+        [:service, :resource, :span_type, :tags].include?(k)
       end
+      opts[:child_of] = call_context
+      span = start_span(name, opts)
 
       # call the finish only if a block is given; this ensures
       # that a call to tracer.trace() without a block, returns
@@ -183,9 +256,15 @@ module Datadog
       if block_given?
         begin
           yield(span)
-        rescue StandardError => e
+        # rubocop:disable Lint/RescueException
+        # Here we really want to catch *any* exception, not only StandardError,
+        # as we really have no clue of what is in the block,
+        # and it is user code which should be executed no matter what.
+        # It's not a problem since we re-raise it afterwards so for example a
+        # SignalException::Interrupt would still bubble up.
+        rescue Exception => e
           span.set_error(e)
-          raise
+          raise e
         ensure
           span.finish()
         end
@@ -194,61 +273,38 @@ module Datadog
       end
     end
 
-    # Record the given finished span in the +spans+ list. When a +span+ is recorded, it will be sent
-    # to the Datadog trace agent as soon as the trace is finished.
-    def record(span)
-      span.service ||= default_service
-
-      spans = []
-      @mutex.synchronize do
-        @spans << span
-        parent = span.parent
-        # Bubble up until we find a non-finished parent. This is necessary for
-        # the case when the parent finished after its parent.
-        parent = parent.parent while !parent.nil? && parent.finished?
-        @buffer.set(parent)
-
-        return unless parent.nil?
-
-        # In general, all spans within the buffer belong to the same trace.
-        # But in heavily multithreaded contexts and/or when using lots of callbacks
-        # hooks and other non-linear programming style, one can technically
-        # end up in different situations. So we only extract the spans which
-        # are associated to the root span that just finished, and save the
-        # others for later.
-        trace_spans = []
-        alien_spans = []
-        @spans.each do |s|
-          if s.trace_id == span.trace_id
-            trace_spans << s
-          else
-            alien_spans << s
-          end
-        end
-        spans = trace_spans
-        @spans = alien_spans
-      end
-
-      return if spans.empty? || !span.sampled
-      write(spans)
+    # Record the given +context+. For compatibility with previous versions,
+    # +context+ can also be a span. It is similar to the +child_of+ argument,
+    # method will figure out what to do, submitting a +span+ for recording
+    # is like trying to record its +context+.
+    def record(context)
+      context = context.context if context.is_a?(Datadog::Span)
+      return if context.nil?
+      trace, sampled = context.get
+      ready = !trace.nil? && !trace.empty? && sampled
+      write(trace) if ready
     end
 
     # Return the current active span or +nil+.
     def active_span
-      @buffer.get()
+      call_context.current_span
     end
 
-    def write(spans)
+    # Send the trace to the writer to enqueue the spans list in the agent
+    # sending queue.
+    def write(trace)
       return if @writer.nil? || !@enabled
 
       if Datadog::Tracer.debug_logging
-        Datadog::Tracer.log.debug("Writing #{spans.length} spans (enabled: #{@enabled})")
-        PP.pp(spans)
+        Datadog::Tracer.log.debug("Writing #{trace.length} spans (enabled: #{@enabled})")
+        str = String.new('')
+        PP.pp(trace, str)
+        Datadog::Tracer.log.debug(str)
       end
 
-      @writer.write(spans, @services)
+      @writer.write(trace, @services)
     end
 
-    private :write
+    private :write, :guess_context_and_parent
   end
 end