instana 1.9.7 → 1.10.0.slimfast

data/lib/instana/tracing/processor.rb

@@ -2,78 +2,43 @@ require 'thread'
 
 module Instana
   class Processor
-
     def initialize
       # The main queue before being reported to the
-      # host agent.  Traces in this queue are complete
+      # host agent.  Spans in this queue are complete
       # and ready to be sent.
       @queue = Queue.new
 
-      # The staging queue that holds traces that have completed
-      # but still have outstanding async spans.
-      # Traces that have been in this queue for more than
-      # 5 minutes are discarded.
-      @staging_queue = Set.new
-
-      # No access to the @staging_queue until this lock
-      # is taken.
-      @staging_lock = Mutex.new
-
       # This is the maximum number of spans we send to the host
       # agent at once.
       @batch_size = 3000
     end
 
-    # Adds a trace to the queue to be processed and
-    # sent to the host agent
+    # Adds a Set of spans to the queue
     #
-    # @param [Trace] the trace to be added to the queue
-    def add(trace)
+    # @param [spans] - the trace to be added to the queue
+    def add_spans(spans)
       # Do a quick checkup on our background thread.
       if ::Instana.agent.collect_thread.nil? || !::Instana.agent.collect_thread.alive?
         ::Instana.agent.spawn_background_thread
       end
-
-      # ::Instana.logger.debug("Queuing completed trace id: #{trace.id}")
-      @queue.push(trace)
+      spans.each { |span| @queue.push(span)}
     end
 
-    # Adds a trace to the staging queue.
+    # Adds a span to the span queue
     #
-    # @param [Trace] the trace to be added to the queue
-    def stage(trace)
-      ::Instana.logger.debug("Staging incomplete trace id: #{trace.id}")
-      @staging_queue.add(trace)
-    end
-
-    # This will run through the staged traces (if any) to find
-    # completed or timed out incompleted traces.  Completed traces will
-    # be added to the main @queue.  Timed out traces will be discarded
-    #
-    def process_staged
-      @staging_lock.synchronize {
-        if @staging_queue.size > 0
-          @staging_queue.delete_if do |t|
-            if t.complete?
-              ::Instana.logger.debug("Moving staged complete trace to main queue: #{t.id}")
-              add(t)
-              true
-            elsif t.discard?
-              ::Instana.logger.debug("Discarding trace with uncompleted async spans over 5 mins old. id: #{t.id}")
-              true
-            else
-              false
-            end
-          end
-        end
-      }
+    # @param [Trace] - the trace to be added to the queue
+    def add_span(span)
+      # Do a quick checkup on our background thread.
+      if ::Instana.agent.collect_thread.nil? || !::Instana.agent.collect_thread.alive?
+        ::Instana.agent.spawn_background_thread
+      end
+      @queue.push(span)
     end
 
     ##
     # send
     #
-    # Sends all traces in @queue to the host
-    # agent
+    # Sends all traces in @queue to the host agent
     #
     # FIXME: Add limits checking here in regards to:
     #   - Max HTTP Post size
@@ -83,15 +48,6 @@ module Instana
     def send
       return if @queue.empty? || ENV.key?('INSTANA_TEST')
 
-      size = @queue.size
-      if size > 200
-        Instana.logger.debug "Trace queue is #{size}"
-      end
-
-      # Scan for any staged but incomplete traces that have now
-      # completed.
-      process_staged
-
       # Retrieve all spans for queued traces
       spans = queued_spans
 
@@ -117,85 +73,15 @@ module Instana
       spans = []
       until @queue.empty? do
         # Non-blocking pop; ignore exception
-        trace = @queue.pop(true) rescue nil
-        trace.spans.each do |s|
-          spans << s.raw
+        span = @queue.pop(true) rescue nil
+        if span
+          spans << span.raw
         end
       end
       spans
     end
 
-    # Retrieves all of the traces that are in @queue.
-    # Note that traces retrieved with this method are removed
-    # entirely from the queue.
-    #
-    # @return [Array] An array of [Trace] or empty
-    #
-    def queued_traces
-      return [] if @queue.empty?
-
-      traces = []
-      until @queue.empty? do
-        # Non-blocking pop; ignore exception
-        traces << @queue.pop(true) rescue nil
-      end
-      traces
-    end
-
-    # Retrieves a all staged traces from the staging queue.  Staged traces
-    # are traces that have completed but may have outstanding
-    # asynchronous spans.
-    #
-    # @return [Array]
-    #
-    def staged_traces
-      traces = nil
-      @staging_lock.synchronize {
-        traces = @staging_queue.to_a
-        @staging_queue.clear
-      }
-      traces
-    end
-
-    # Retrieves a single staged trace from the staging queue.  Staged traces
-    # are traces that have completed but may have outstanding
-    # asynchronous spans.
-    #
-    # @param trace_id [Integer] the Trace ID to be searched for
-    #
-    def staged_trace(trace_id)
-      candidate = nil
-      @staging_lock.synchronize {
-        @staging_queue.each do |trace|
-          if trace.id == trace_id
-            candidate = trace
-            break
-          end
-        end
-      }
-      unless candidate
-        ::Instana.logger.debug("Couldn't find staged trace with trace_id: #{trace_id}")
-      end
-      candidate
-    end
-
-    # Get the number traces currently in the queue
-    #
-    # @return [Integer] the queue size
-    #
-    def queue_count
-      @queue.size
-    end
-
-    # Get the number traces currently in the staging queue
-    #
-    # @return [Integer] the queue size
-    #
-    def staged_count
-      @staging_queue.size
-    end
-
-    # Removes all traces from the @queue and @staging_queue.  Used in the
+    # Removes all traces from the @queue.  Used in the
     # test suite to reset state.
     #
     def clear!
@@ -203,7 +89,6 @@ module Instana
         # Non-blocking pop; ignore exception
         @queue.pop(true) rescue nil
       end
-      @staging_queue.clear
     end
   end
 end

data/lib/instana/tracing/span.rb

@@ -11,13 +11,33 @@ module Instana
 
     attr_accessor :parent
     attr_accessor :baggage
+    attr_accessor :is_root
+    attr_accessor :context
 
-    def initialize(name, trace_id, parent_id: nil, start_time: ::Instana::Util.now_in_ms)
+    def initialize(name, parent_ctx: nil, start_time: ::Instana::Util.now_in_ms)
       @data = {}
-      @data[:t] = trace_id                    # Trace ID
-      @data[:s] = ::Instana::Util.generate_id # Span ID
-      @data[:p] = parent_id if parent_id      # Parent ID
-      @data[:ta] = :ruby                      # Agent
+
+      if parent_ctx == nil
+        # No parent specified so we're starting a new Trace - this will be the root span
+        id = ::Instana::Util.generate_id
+        @data[:t] = id                    # Trace ID
+        @data[:s] = id                    # Span ID
+        is_root = true
+      else
+        if parent_ctx.is_a?(::Instana::Span)
+          @parent = parent_ctx
+          parent_context = parent_ctx.context
+        elsif parent_ctx.is_a?(::Instana::SpanContext)
+          parent_context = parent_ctx
+        end
+
+        @data[:t] = parent_context.trace_id       # Trace ID
+        @data[:s] = ::Instana::Util.generate_id # Span ID
+        @data[:p] = parent_context.span_id        # Parent ID
+        @baggage = parent_ctx.baggage.dup
+        is_root = false
+      end
+
       @data[:data] = {}
 
       # Entity Source
@@ -30,8 +50,6 @@ module Instana
         @data[:ts] = start_time
       end
 
-      @baggage = {}
-
       if ::Instana.config[:collect_backtraces]
         # For entry spans, add a backtrace fingerprint
         add_stack(limit: 2) if ENTRY_SPANS.include?(name)
@@ -119,7 +137,7 @@ module Instana
     #
     def configure_custom(name)
       @data[:n] = :sdk
-      @data[:k] = :intermediate
+      @data[:k] = 3
       @data[:data] = { :sdk => { :name => name.to_sym, :type => :intermediate } }
       @data[:data][:sdk][:custom] = { :tags => {}, :logs => {} }
       self
@@ -133,12 +151,15 @@ module Instana
     # @return [Span]
     #
     def close(end_time = ::Instana::Util.now_in_ms)
-
       if end_time.is_a?(Time)
         end_time = ::Instana::Util.time_to_ms(end_time)
       end
 
       @data[:d] = end_time - @data[:ts]
+
+      # Add this span to the queue for reporting
+      ::Instana.processor.add_span(self)
+
       self
     end
 
@@ -151,7 +172,7 @@ module Instana
     # @return [Instana::SpanContext]
     #
     def context
-      @context ||= ::Instana::SpanContext.new(@data[:t], @data[:s], @baggage)
+      @context ||= ::Instana::SpanContext.new(@data[:t], @data[:s], 1, @baggage)
     end
 
     # Retrieve the ID for this span
@@ -212,15 +233,6 @@ module Instana
       @data[:d]
     end
 
-    # Indicates whether this span in the root span
-    # in the Trace
-    #
-    # @return [Boolean]
-    #
-    def is_root?
-      @data[:s] == @data[:t]
-    end
-
     # Hash accessor to the internal @data hash
     #
     def [](key)
@@ -283,11 +295,14 @@ module Instana
         if key.to_sym == :'span.kind'
           case value.to_sym
           when :server, :consumer
-            @data[:data][:sdk][:type] = @data[:k] = :entry
+            @data[:data][:sdk][:type] = :entry
+            @data[:k] = 1
           when :client, :producer
-            @data[:data][:sdk][:type] = @data[:k] = :exit
+            @data[:data][:sdk][:type] = :exit
+            @data[:k] = 2
           else
-            @data[:data][:sdk][:type] = @data[:k] = :intermediate
+            @data[:data][:sdk][:type] = :intermediate
+            @data[:k] = 3
           end
         end
       else
@@ -328,7 +343,7 @@ module Instana
       if @context
         @context.baggage = @baggage
       else
-        @context ||= ::Instana::SpanContext.new(@data[:t], @data[:s], @baggage)
+        @context ||= ::Instana::SpanContext.new(@data[:t], @data[:s], 1, @baggage)
       end
       self
     end
@@ -370,7 +385,7 @@ module Instana
         set_tags(:log => fields)
       end
     rescue StandardError => e
-      Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+      Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
     end
 
     # Finish the {Span}
@@ -379,17 +394,7 @@ module Instana
     # @param end_time [Time] custom end time, if not now
     #
     def finish(end_time = ::Instana::Util.now_in_ms)
-      if ::Instana.tracer.current_span.id != id
-        ::Instana.logger.debug "Closing a span that isn't active. This will result in a broken trace: #{self.inspect}"
-      end
-
-      if is_root?
-        # This is the root span for the trace.  Call log_end to close
-        # out and queue the trace
-        ::Instana.tracer.log_end(name, {}, end_time)
-      else
-        ::Instana.tracer.current_trace.end_span({}, end_time)
-      end
+      close(end_time)
       self
     end
   end

data/lib/instana/tracing/span_context.rb

@@ -8,11 +8,13 @@ module Instana
     #
     # @param tid [Integer] the trace ID
     # @param sid [Integer] the span ID
+    # @param level [Integer] default 1
     # @param baggage [Hash] baggage applied to this trace
     #
-    def initialize(tid, sid, baggage = nil)
+    def initialize(tid, sid, level = 1, baggage = nil)
       @trace_id = tid
       @span_id = sid
+      @level = level
       @baggage = baggage
     end
 

data/lib/instana/util.rb

@@ -119,8 +119,8 @@ module Instana
 
         data
       rescue => e
-        ::Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-        ::Instana.logger.debug e.backtrace.join("\r\n")
+        ::Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+        ::Instana.logger.debug { e.backtrace.join("\r\n") }
         return data
       end
 
@@ -187,7 +187,7 @@ module Instana
         return File.basename($0)
       rescue Exception => e
         Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-        Instana.logger.debug e.backtrace.join("\r\n")
+        Instana.logger.debug { e.backtrace.join("\r\n") }
       end
 
       # Get the current time in milliseconds from the epoch
@@ -231,7 +231,7 @@ module Instana
         [id.to_i].pack('q>').unpack('H*')[0].gsub(/^0+/, '')
       rescue => e
         Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-        Instana.logger.debug e.backtrace.join("\r\n")
+        Instana.logger.debug { e.backtrace.join("\r\n") }
       end
 
       # Convert a received header value into a valid ID
@@ -254,7 +254,7 @@ module Instana
         [header_id].pack("H*").unpack("q>")[0]
       rescue => e
         Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-        Instana.logger.debug e.backtrace.join("\r\n")
+        Instana.logger.debug { e.backtrace.join("\r\n") }
       end
     end
   end

data/lib/instana/version.rb

@@ -1,4 +1,4 @@
 module Instana
-  VERSION = "1.9.7"
+  VERSION = "1.10.0.slimfast"
   VERSION_FULL = "instana-#{VERSION}"
 end

data/lib/opentracing.rb

@@ -2,5 +2,5 @@ require "instana/opentracing/tracer"
 require "instana/opentracing/carrier"
 
 # Set the global tracer to our OT tracer
-# which supports the OT specificiation
+# which supports the OT specification
 OpenTracing.global_tracer = ::Instana.tracer

data/test/frameworks/rack_test.rb

@@ -31,7 +31,6 @@ class RackTest < Minitest::Test
 
     first_span = spans.first
     assert_equal :rack, first_span[:n]
-    assert_equal :ruby, first_span[:ta]
     assert first_span.key?(:data)
     assert first_span[:data].key?(:http)
     assert_equal "GET", first_span[:data][:http][:method]
@@ -78,7 +77,6 @@ class RackTest < Minitest::Test
     assert_equal 1, spans.count
     first_span = spans.first
     assert_equal :rack, first_span[:n]
-    assert_equal :ruby, first_span[:ta]
     assert first_span.key?(:data)
     assert first_span[:data].key?(:http)
     assert_equal "POST", first_span[:data][:http][:method]
@@ -101,7 +99,6 @@ class RackTest < Minitest::Test
     assert_equal 1, spans.count
     first_span = spans.first
     assert_equal :rack, first_span[:n]
-    assert_equal :ruby, first_span[:ta]
     assert first_span.key?(:data)
     assert first_span[:data].key?(:http)
     assert_equal "PUT", first_span[:data][:http][:method]
@@ -127,7 +124,6 @@ class RackTest < Minitest::Test
     assert_equal 1, spans.count
     first_span = spans.first
     assert_equal :rack, first_span[:n]
-    assert_equal :ruby, first_span[:ta]
     assert first_span.key?(:data)
     assert first_span[:data].key?(:http)
     assert_equal "GET", first_span[:data][:http][:method]
@@ -158,14 +154,13 @@ class RackTest < Minitest::Test
     clear_all!
     get '/mrlobster?blah=2&wilma=1&betty=2;fred=3'
 
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.length
 
-    trace = traces[0]
-    refute_nil trace.spans.first.key?(:data)
-    refute_nil trace.spans.first[:data].key?(:http)
-    refute_nil trace.spans.first[:data][:http].key?(:url)
-    assert_equal '/mrlobster', trace.spans.first[:data][:http][:url]
+    refute_nil spans.first.key?(:data)
+    refute_nil spans.first[:data].key?(:http)
+    refute_nil spans.first[:data][:http].key?(:url)
+    assert_equal '/mrlobster', spans.first[:data][:http][:url]
 
     assert last_response.ok?
   end