instana 1.9.7 → 1.10.0.slimfast

data/test/tracing/tracer_test.rb

@@ -30,15 +30,11 @@ class TracerTest < Minitest::Test
       sleep 0.1
     end
 
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    t = traces.first
-    assert_equal 1, t.spans.size
-    assert t.valid?
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.length
 
-    first_span = t.spans.first
+    first_span = spans.first
     assert_equal :rack, first_span[:n]
-    assert_equal :ruby, first_span[:ta]
     assert first_span[:ts].is_a?(Integer)
     assert first_span[:d].is_a?(Integer)
     assert first_span[:d].between?(100, 130)
@@ -63,15 +59,11 @@ class TracerTest < Minitest::Test
 
     assert exception_raised
 
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    t = traces.first
-    assert_equal 1, t.spans.size
-    assert t.valid?
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.length
 
-    first_span = t.spans.first
+    first_span = spans.first
     assert_equal :rack, first_span[:n]
-    assert_equal :ruby, first_span[:ta]
     assert first_span[:ts].is_a?(Integer)
     assert first_span[:ts] > 0
     assert first_span[:d].is_a?(Integer)
@@ -82,7 +74,8 @@ class TracerTest < Minitest::Test
     assert first_span[:f].key?(:e)
     assert first_span[:f].key?(:h)
     assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
-    assert t.has_error?
+    assert_equal first_span[:error], true
+    assert_equal first_span[:ec], 1
   end
 
   def test_complex_trace_block
@@ -94,11 +87,22 @@ class TracerTest < Minitest::Test
       end
     end
 
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    t = traces.first
-    assert_equal 2, t.spans.size
-    assert t.valid?
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
+
+    rack_span = find_first_span_by_name(spans, :rack)
+    sdk_span = find_first_span_by_name(spans, :sub_block)
+
+    assert_equal rack_span[:n], :rack
+    assert_equal rack_span[:p], nil
+    assert_equal rack_span[:t], rack_span[:s]
+    assert_equal rack_span[:data][:one], 1
+
+    assert_equal sdk_span[:n], :sdk
+    assert_equal sdk_span[:data][:sdk][:name], :sub_block
+    assert_equal sdk_span[:data][:sdk][:type], :intermediate
+    assert_equal sdk_span[:k], 3
+    assert_equal sdk_span[:data][:sdk][:custom][:tags][:sub_two], 2
   end
 
   def test_basic_low_level_tracing
@@ -113,11 +117,8 @@ class TracerTest < Minitest::Test
     ::Instana.tracer.log_end(:rack, {:close_one => 1})
     assert_equal false, ::Instana.tracer.tracing?
 
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    t = traces.first
-    assert_equal 1, t.spans.size
-    assert t.valid?
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.length
   end
 
   def test_complex_low_level_tracing
@@ -142,22 +143,30 @@ class TracerTest < Minitest::Test
     ::Instana.tracer.log_end(:rack, {:close_one => 1})
     assert_equal false, ::Instana.tracer.tracing?
 
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
 
-    t = traces.first
-    assert_equal 2, t.spans.size
-    assert t.valid?
+    rack_span = find_first_span_by_name(spans, :rack)
+    sdk_span = find_first_span_by_name(spans, :sub_task)
+
+    assert_equal :rack, rack_span[:n]
+    assert rack_span.key?(:data)
+    assert_equal rack_span[:data][:one], 1
+    assert_equal rack_span[:data][:info_logged], 1
+    assert_equal rack_span[:data][:close_one], 1
+
+    assert rack_span.key?(:f)
+    assert rack_span[:f].key?(:e)
+    assert rack_span[:f].key?(:h)
+    assert_equal ::Instana.agent.agent_uuid, rack_span[:f][:h]
+
+    assert_equal sdk_span[:n], :sdk
+    assert_equal sdk_span[:data][:sdk][:name], :sub_task
+    assert_equal sdk_span[:data][:sdk][:type], :intermediate
+    assert_equal sdk_span[:k], 3
+    assert_equal sdk_span[:data][:sdk][:custom][:tags][:sub_task_info], 1
+    assert_equal sdk_span[:data][:sdk][:custom][:tags][:sub_task_exit_info], 1
 
-    first_span = t.spans.first
-    assert_equal :rack, first_span[:n]
-    assert_equal :ruby, first_span[:ta]
-    assert first_span.key?(:data)
-    assert_equal 1, first_span[:data][:one]
-    assert first_span.key?(:f)
-    assert first_span[:f].key?(:e)
-    assert first_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
   end
 
   def test_block_tracing_error_capture
@@ -173,13 +182,19 @@ class TracerTest < Minitest::Test
 
     assert exception_raised
 
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.length
+
+    sdk_span = spans[0]
 
-    t = traces.first
-    assert_equal 1, t.spans.size
-    assert t.valid?
-    assert t.has_error?
+    assert_equal sdk_span[:n], :sdk
+    assert_equal sdk_span[:data][:sdk][:name], :test_trace
+    assert_equal sdk_span[:data][:sdk][:type], :intermediate
+    assert_equal sdk_span[:k], 3
+    assert_equal sdk_span[:data][:sdk][:custom][:tags][:one], 1
+    assert_equal sdk_span[:error], true
+    assert_equal sdk_span[:ec], 1
+    assert_equal sdk_span.key?(:stack), true
   end
 
   def test_low_level_error_logging
@@ -189,35 +204,20 @@ class TracerTest < Minitest::Test
     ::Instana.tracer.log_error(Exception.new("Low level tracing api error"))
     ::Instana.tracer.log_end(:test_trace, {:close_one => 1})
 
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
-
-    t = traces.first
-    assert_equal 1, t.spans.size
-    assert t.valid?
-    assert t.has_error?
-  end
-
-  def test_instana_headers_in_response
-    clear_all!
-    ::Instana.tracer.start_or_continue_trace(:rack, {:one => 1}) do
-      sleep 0.5
-    end
-
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    t = traces.first
-    assert_equal 1, t.spans.size
-    assert t.valid?
-
-    first_span = t.spans.first
-    assert_equal :rack, first_span[:n]
-    assert_equal :ruby, first_span[:ta]
-    assert first_span.key?(:data)
-    assert_equal 1, first_span[:data][:one]
-    assert first_span.key?(:f)
-    assert first_span[:f].key?(:e)
-    assert first_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.length
+
+    sdk_span = spans[0]
+
+    assert_equal sdk_span[:n], :sdk
+    assert_equal sdk_span[:data][:sdk][:name], :test_trace
+    assert_equal sdk_span[:data][:sdk][:type], :intermediate
+    assert_equal sdk_span[:k], 3
+    assert_equal sdk_span[:data][:sdk][:custom][:tags][:one], 1
+    assert_equal sdk_span[:data][:sdk][:custom][:tags][:info_logged], 1
+    assert_equal sdk_span[:data][:sdk][:custom][:tags][:close_one], 1
+    assert_equal sdk_span[:error], true
+    assert_equal sdk_span[:ec], 1
+    assert_equal sdk_span.key?(:stack), false
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: instana
 version: !ruby/object:Gem::Version
-  version: 1.9.7
+  version: 1.10.0.slimfast
 platform: ruby
 authors:
 - Peter Giacomo Lombardo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-14 00:00:00.000000000 Z
+date: 2019-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -245,7 +245,6 @@ files:
 - lib/instana/tracing/processor.rb
 - lib/instana/tracing/span.rb
 - lib/instana/tracing/span_context.rb
-- lib/instana/tracing/trace.rb
 - lib/instana/util.rb
 - lib/instana/version.rb
 - lib/opentracing.rb
@@ -311,9 +310,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
 signing_key: 

data/lib/instana/tracing/trace.rb

@@ -1,316 +0,0 @@
-module Instana
-  class Trace
-    # @return [Integer] the ID for this trace
-    attr_reader :id
-
-    # The collection of `Span` for this trace
-    # @return [Set] the collection of spans for this trace
-    attr_reader :spans
-
-    # The currently active span
-    attr_reader :current_span
-
-    # Initializes a new instance of Trace
-    #
-    # @param name [String] the name of the span to start
-    # @param kvs [Hash] list of key values to be reported in the span
-    # @param incoming_context [Hash] specifies the incoming context.  At a
-    #   minimum, it should specify :trace_id and :span_id from the following:
-    #     :trace_id the trace ID (must be an unsigned hex-string)
-    #     :span_id the ID of the parent span (must be an unsigned hex-string)
-    #     :level specifies data collection level (optional)
-    #
-    def initialize(name, kvs = nil, incoming_context = {}, start_time = ::Instana::Util.now_in_ms)
-      # The collection of spans that make
-      # up this trace.
-      @spans = Set.new
-
-      # Generate a random 64bit ID for this trace
-      @id = ::Instana::Util.generate_id
-
-      # Indicates the time when this trace was started.  Used to timeout
-      # traces that have asynchronous spans that never close out.
-      @started_at = Time.now
-
-      # Indicates if this trace has any asynchronous spans within it
-      @has_async = false
-
-      # This is a new trace so open the first span with the proper
-      # root span IDs.
-      @current_span = Span.new(name, @id, start_time: start_time)
-      @current_span.set_tags(kvs) if kvs
-
-      # Handle potential incoming context
-      if !incoming_context || incoming_context.empty?
-        # No incoming context. Set trace ID the same
-        # as this first span.
-        @current_span[:s] = @id
-      else
-        @id = incoming_context[:trace_id]
-        @current_span[:t] = incoming_context[:trace_id]
-        @current_span[:p] = incoming_context[:span_id]
-      end
-
-      @spans.add(@current_span)
-    end
-
-    # Start a new span as a child of @current_span
-    #
-    # @param name [String] the name of the span to start
-    # @param kvs [Hash] list of key values to be reported in the span
-    #
-    def new_span(name, kvs = nil, start_time = ::Instana::Util.now_in_ms, child_of = nil)
-      return unless @current_span
-
-      if child_of && child_of.is_a?(::Instana::Span)
-        new_span = Span.new(name, @id, parent_id: child_of.id, start_time: start_time)
-        new_span.parent = child_of
-        new_span.baggage = child_of.baggage.dup
-      else
-        new_span = Span.new(name, @id, parent_id: @current_span.id, start_time: start_time)
-        new_span.parent = @current_span
-        new_span.baggage = @current_span.baggage.dup
-      end
-      new_span.set_tags(kvs) if kvs
-
-      @spans.add(new_span)
-      @current_span = new_span
-    end
-
-    # Add KVs to the current span
-    #
-    # @param span [Span] the span to add kvs to or otherwise the current span
-    # @param kvs [Hash] list of key values to be reported in the span
-    #
-    def add_info(kvs, span = nil)
-      return unless @current_span
-      span ||= @current_span
-
-      # Pass on to the OT span interface which will properly
-      # apply KVs based on span type
-      span.set_tags(kvs)
-    end
-
-    # Log an error into the current span
-    #
-    # @param e [Exception] Add exception to the current span
-    #
-    def add_error(e, span = nil)
-      # Return if we've already logged this exception and it
-      # is just propogating up the spans.
-      return if e && e.instance_variable_get(:@instana_logged) || @current_span.nil?
-      span ||= @current_span
-      span.add_error(e)
-    end
-
-    # Close out the current span and set the parent as
-    # the current span
-    #
-    # @param kvs [Hash] list of key values to be reported in the span
-    #
-    def end_span(kvs = {}, end_time = ::Instana::Util.now_in_ms)
-      return unless @current_span
-
-      @current_span.close(end_time)
-      add_info(kvs) if kvs && !kvs.empty?
-      @current_span = @current_span.parent unless @current_span.is_root?
-    end
-    alias finish end_span
-
-    ###########################################################################
-    # Asynchronous Methods
-    ###########################################################################
-
-    # Start a new asynchronous span
-    #
-    # The major differentiator between this method and simple new_span is that
-    # this method doesn't affect @current_trace and instead returns an
-    # ID pair that can be used later to close out the created async span.
-    #
-    # @param name [String] the name of the span to start
-    # @param kvs [Hash] list of key values to be reported in the span
-    #
-    def new_async_span(name, kvs = {})
-      new_span = Span.new(name, @id, parent_id: @current_span.id)
-      new_span.set_tags(kvs) unless kvs.empty?
-      new_span.parent = @current_span
-      new_span[:deferred] = @has_async = true
-
-      # Add the new span to the span collection
-      @spans.add(new_span)
-      new_span
-    end
-
-    # Log info into an asynchronous span
-    #
-    # @param kvs [Hash] list of key values to be reported in the span
-    # @param span [Span] the span of this Async op (previously returned
-    #   from `log_async_entry`)
-    #
-    def add_async_info(kvs, span)
-      span.set_tags(kvs)
-    end
-
-    # Log an error into an asynchronous span
-    #
-    # @param e [Exception] Add exception to the current span
-    # @param span [Span] the span of this Async op (previously returned
-    #   from `log_async_entry`)
-    #
-    def add_async_error(e, span)
-      span.add_error(e)
-    end
-
-    # End an asynchronous span
-    #
-    # @param name [Symbol] the name of the span
-    # @param kvs [Hash] list of key values to be reported in the span
-    # @param span [Span] the span of this Async op (previously returned
-    #   from `log_async_entry`)
-    #
-    def end_async_span(kvs = {}, span)
-      span.set_tags(kvs) unless kvs.empty?
-      span.close
-    end
-
-    ###########################################################################
-    # Validator and Helper Methods
-    ###########################################################################
-
-    # Indicates whether all seems ok with this trace in it's current state.
-    # Should be only called on finished traces.
-    #
-    # @return [Boolean] true or false on whether this trace is valid
-    #
-    def valid?
-      @spans.each do |span|
-        unless span.key?(:d)
-          return false
-        end
-      end
-      true
-    end
-
-    # Indicates if every span of this trace has completed.  Useful when
-    # asynchronous spans potentially could run longer than the parent trace.
-    #
-    def complete?
-      @spans.each do |span|
-        if !span.duration
-          return false
-        end
-      end
-      true
-    end
-
-    # Indicates whether this trace has any asynchronous spans.
-    #
-    def has_async?
-      @has_async
-    end
-
-    # Searches the set of spans and indicates if there
-    # is an error logged in one of them.
-    #
-    # @return [Boolean] true or false indicating the presence
-    #   of an error
-    #
-    def has_error?
-      @spans.each do |s|
-        if s.key?(:error)
-          if s[:error] == true
-            return true
-          end
-        end
-      end
-      false
-    end
-
-    # Get the ID of the current span for this trace.
-    # Used often to place in HTTP response headers.
-    #
-    # @return [Integer] a random 64bit integer
-    #
-    def current_span_id
-      @current_span.id
-    end
-
-    # Get the name of the current span.  Supports both registered spans
-    # and custom sdk spans.
-    #
-    def current_span_name
-      @current_span.name
-    end
-
-    # Check if the current span has the name value of <name>
-    #
-    # @param name [Symbol] The name to be checked against.
-    #
-    # @return [Boolean]
-    #
-    def current_span_name?(name)
-      @current_span.name == name
-    end
-
-    # For traces that have asynchronous spans, this method indicates
-    # whether we have hit the timeout on waiting for those async
-    # spans to close out.
-    #
-    # @return [Boolean]
-    #
-    def discard?
-      # If this trace has async spans that have not closed
-      # out in 5 minutes, then it's discarded.
-      if has_async? && (Time.now.to_i - @started_at.to_i) > 601
-        return true
-      end
-      false
-    end
-
-    private
-
-    # Configure @current_span to be a custom span per the
-    # SDK generic span type.
-    #
-    # @param span [Span] the span to configure or nil
-    # @param name [String] name of the span
-    # @param kvs [Hash] list of key values to be reported in the span
-    #
-    def configure_custom_span(span, name, kvs = {})
-      span ||= @current_span
-      span.configure_custom(name, kvs)
-    end
-
-    # Adds the passed in backtrace to the specified span.  Backtrace can be one
-    # generated from Kernel.caller or one attached to an exception
-    #
-    # @param bt [Array] the backtrace
-    # @param limit [Integer] Limit the backtrace to the top <limit> frames
-    # @param span [Span] the span to add the backtrace to or if unspecified
-    #   the current span
-    #
-    def add_backtrace_to_span(bt, limit = nil, span)
-      frame_count = 0
-      span[:stack] = []
-
-      bt.each do |i|
-        # If the stack has the full instana gem version in it's path
-        # then don't include that frame. Also don't exclude the Rack module.
-        if !i.match(/instana\/instrumentation\/rack.rb/).nil? ||
-          (i.match(::Instana::VERSION_FULL).nil? && i.match('lib/instana/').nil?)
-
-          break if limit && frame_count >= limit
-
-          x = i.split(':')
-
-          span[:stack] << {
-            :f => x[0],
-            :n => x[1],
-            :m => x[2]
-          }
-         frame_count = frame_count + 1 if limit
-        end
-      end
-    end
-  end
-end