instana 1.10.1-java

data/test/tracing/trace_test.rb

@@ -0,0 +1,67 @@
+# require 'test_helper'
+#
+# class TraceTest < Minitest::Test
+#   def test_trace_spans_count
+#     t = ::Instana::Trace.new(:test_trace, { :one => 1, :two => 2 })
+#     t.new_span(:sub_span, { :sub_four => 4 })
+#     t.end_span(:sub_five => 5)
+#     t.end_span(:three => 3)
+#     assert t.spans.size == 2
+#   end
+#
+#   def test_trace_with_incoming_context
+#     incoming_context = { :trace_id => "1234", :span_id => "4321" }
+#     t = ::Instana::Trace.new(:test_trace, { :one => 1, :two => 2 }, incoming_context)
+#     first_span = t.spans.first
+#     assert_equal "1234", first_span[:t]
+#     assert_equal "4321", first_span[:p]
+#     assert t.spans.size == 1
+#   end
+#
+#   def test_max_value_of_generated_id
+#     # Max is the maximum value for a Java signed long
+#     max_value = 9223372036854775807
+#     1000.times do
+#       assert ::Instana::Util.generate_id <= max_value
+#     end
+#   end
+#
+#   def test_min_value_of_generated_id
+#     # Max is the maximum value for a Java signed long
+#     max_value = -9223372036854775808
+#     1000.times do
+#       assert ::Instana::Util.generate_id >= max_value
+#     end
+#   end
+#
+#   def test_entry_span_doesnt_have_stack_by_default
+#     t = ::Instana::Trace.new(:rack)
+#     first_span = t.spans.first
+#     assert !first_span.key?(:stack)
+#   end
+#
+#   def test_entry_span_has_stack_by_config
+#     ::Instana.config[:collect_backtraces] = true
+#     t = ::Instana::Trace.new(:rack)
+#     first_span = t.spans.first
+#     assert first_span.key?(:stack)
+#     assert_equal 2, first_span[:stack].count
+#     ::Instana.config[:collect_backtraces] = false
+#   end
+#
+#   def test_exit_span_doesnt_have_stack_by_default
+#     t = ::Instana::Trace.new(:trace_test)
+#     t.new_span(:excon)
+#     second_span = t.spans.to_a[1]
+#     assert !second_span.key?(:stack)
+#   end
+#
+#   def test_exit_span_has_stack_by_config
+#     ::Instana.config[:collect_backtraces] = true
+#     t = ::Instana::Trace.new(:trace_test)
+#     t.new_span(:excon)
+#     second_span = t.spans.to_a[1]
+#     assert second_span.key?(:stack)
+#     ::Instana.config[:collect_backtraces] = false
+#   end
+# end

data/test/tracing/tracer_async_test.rb

@@ -0,0 +1,198 @@
+require 'test_helper'
+
+class TracerAsyncTest < Minitest::Test
+  def test_same_thread_async_tracing
+    clear_all!
+
+    # Start tracing
+    ::Instana.tracer.log_start_or_continue(:rack, {:rack_start_kv => 1})
+
+    # Start an asynchronous span
+    span = ::Instana.tracer.log_async_entry(:my_async_op, { :entry_kv => 1})
+
+    refute_nil span
+    refute_nil span.context
+
+    # Current span should still be rack
+    assert_equal :rack, ::Instana.tracer.current_span.name
+
+    # End an asynchronous span
+    ::Instana.tracer.log_async_exit(:my_async_op, { :exit_kv => 1 }, span)
+
+    # Current span should still be rack
+    assert_equal :rack, ::Instana.tracer.current_span.name
+
+    # End tracing
+    ::Instana.tracer.log_end(:rack, {:rack_end_kv => 1})
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
+
+    rack_span = find_first_span_by_name(spans, :rack)
+    async_span = find_first_span_by_name(spans, :my_async_op)
+
+    # Both spans have a duration
+    assert rack_span[:d]
+    assert async_span[:d]
+
+    # first_span is the parent of first_span
+    assert_equal rack_span[:s], async_span[:p]
+    # same trace id
+    assert_equal rack_span[:t], async_span[:t]
+
+    # KV checks
+    assert_equal 1, rack_span[:data][:rack_start_kv]
+    assert_equal 1, rack_span[:data][:rack_end_kv]
+    assert_equal 1, async_span[:data][:sdk][:custom][:tags][:entry_kv]
+    assert_equal 1, async_span[:data][:sdk][:custom][:tags][:exit_kv]
+  end
+
+  def test_diff_thread_async_tracing
+    clear_all!
+
+    # Start tracing
+    ::Instana.tracer.log_start_or_continue(:rack, {:rack_start_kv => 1})
+
+    t_context = ::Instana.tracer.context
+    refute_nil t_context.trace_id
+    refute_nil t_context.span_id
+
+    Thread.new do
+      ::Instana.tracer.log_start_or_continue(:async_thread, { :async_start => 1 }, t_context)
+      ::Instana.tracer.log_entry(:sleepy_time, { :tired => 1 })
+      # Sleep beyond the end of this root trace
+      sleep 0.5
+      ::Instana.tracer.log_exit(:sleepy_time, { :wake_up => 1})
+      ::Instana.tracer.log_end(:async_thread, { :async_end => 1 })
+    end
+
+    # Current span should still be rack
+    assert_equal :rack, ::Instana.tracer.current_span.name
+
+    # End tracing
+    ::Instana.tracer.log_end(:rack, {:rack_end_kv => 1})
+
+    assert_equal false, ::Instana.tracer.tracing?
+
+    # Sleep for 1 seconds to wait for the async thread to finish
+    sleep 1
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
+
+    rack_span = find_first_span_by_name(spans, :rack)
+    async_span1 = find_first_span_by_name(spans, :async_thread)
+    async_span2 = find_first_span_by_name(spans, :sleepy_time)
+
+    # Validate the first original thread span
+    assert_equal :rack, rack_span[:n]
+    assert rack_span[:d]
+    assert_equal 1, rack_span[:data][:rack_start_kv]
+    assert_equal 1, rack_span[:data][:rack_end_kv]
+
+    # first span in second trace
+    assert_equal :sdk, async_span1[:n]
+    assert_equal :async_thread, async_span1[:data][:sdk][:name]
+    assert async_span1[:d]
+    assert_equal 1, async_span1[:data][:sdk][:custom][:tags][:async_start]
+    assert_equal 1, async_span1[:data][:sdk][:custom][:tags][:async_end]
+
+    # second span in second trace
+    assert_equal :sdk, async_span2[:n]
+    assert_equal :sleepy_time, async_span2[:data][:sdk][:name]
+    assert async_span2[:d]
+    assert_equal 1, async_span2[:data][:sdk][:custom][:tags][:tired]
+    assert_equal 1, async_span2[:data][:sdk][:custom][:tags][:wake_up]
+
+    # Validate linkage
+    # All spans have the same trace ID
+    assert rack_span[:t]==async_span1[:t] && async_span1[:t]==async_span2[:t]
+
+    assert_equal async_span2[:p], async_span1[:s]
+    assert_equal async_span1[:p], rack_span[:s]
+
+    assert rack_span[:t]  == rack_span[:s]
+    assert async_span1[:t] != async_span1[:s]
+    assert async_span2[:t] != async_span2[:s]
+  end
+
+  def test_out_of_order_async_tracing
+    clear_all!
+
+    # Start tracing
+    ::Instana.tracer.log_start_or_continue(:rack, {:rack_start_kv => 1})
+
+    # Start three asynchronous spans
+    span1 = ::Instana.tracer.log_async_entry(:my_async_op1, { :entry_kv => 1})
+    span2 = ::Instana.tracer.log_async_entry(:my_async_op2, { :entry_kv => 2})
+    span3 = ::Instana.tracer.log_async_entry(:my_async_op3, { :entry_kv => 3})
+
+    # Current span should still be rack
+    assert_equal :rack, ::Instana.tracer.current_span.name
+
+    # Log info to the async spans (out of order)
+    span2.set_tags({ :info_kv => 2 })
+    span1.set_tags({ :info_kv => 1 })
+    span3.set_tags({ :info_kv => 3 })
+
+    # Log out of order errors to the async spans
+    span3.add_error(Exception.new("Async span 3"))
+    span2.add_error(Exception.new("Async span 3"))
+
+    # End two out of order asynchronous spans
+    span3.set_tags({ :exit_kv => 3 })
+    span3.close
+    span2.set_tags({ :exit_kv => 2 })
+    span2.close
+
+    # Current span should still be rack
+    assert_equal :rack, ::Instana.tracer.current_span.name
+
+    # End tracing
+    ::Instana.tracer.log_end(:rack, {:rack_end_kv => 1})
+
+    # Log an error to and close out the remaining async span after the parent trace has finished
+    span1.add_error(Exception.new("Async span 1"))
+    span1.set_tags({ :exit_kv => 1 })
+    span1.close
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 4, spans.length
+
+    first_span  = find_first_span_by_name(spans, :rack)
+    second_span = find_first_span_by_name(spans, :my_async_op1)
+    third_span  = find_first_span_by_name(spans, :my_async_op2)
+    fourth_span = find_first_span_by_name(spans, :my_async_op3)
+
+    # Assure all spans have completed
+    assert first_span.key?(:d)
+    assert second_span.key?(:d)
+    assert third_span.key?(:d)
+    assert fourth_span.key?(:d)
+
+    # Linkage
+    assert_equal first_span[:s], second_span[:p]
+    assert_equal first_span[:s], third_span[:p]
+    assert_equal first_span[:s], fourth_span[:p]
+
+    # same trace id
+    assert_equal first_span[:t], second_span[:t]
+    assert_equal first_span[:t], third_span[:t]
+    assert_equal first_span[:t], fourth_span[:t]
+
+    assert first_span[:n]  != :sdk
+    assert second_span[:n] == :sdk
+    assert third_span[:n]  == :sdk
+    assert fourth_span[:n] == :sdk
+
+    # KV checks
+    assert_equal 1, first_span[:data][:rack_start_kv]
+    assert_equal 1, first_span[:data][:rack_end_kv]
+    assert_equal 1, second_span[:data][:sdk][:custom][:tags][:entry_kv]
+    assert_equal 1, second_span[:data][:sdk][:custom][:tags][:exit_kv]
+    assert_equal 2, third_span[:data][:sdk][:custom][:tags][:entry_kv]
+    assert_equal 2, third_span[:data][:sdk][:custom][:tags][:exit_kv]
+    assert_equal 3, fourth_span[:data][:sdk][:custom][:tags][:entry_kv]
+    assert_equal 3, fourth_span[:data][:sdk][:custom][:tags][:exit_kv]
+  end
+end

data/test/tracing/tracer_test.rb

@@ -0,0 +1,223 @@
+require 'test_helper'
+
+class TracerTest < Minitest::Test
+  def test_that_it_has_a_valid_tracer
+    refute_nil ::Instana.tracer
+    assert ::Instana.tracer.is_a?(::Instana::Tracer)
+  end
+
+  def test_obey_tracing_config
+    clear_all!
+
+    ::Instana.config[:tracing][:enabled] = false
+    assert_equal false, ::Instana.tracer.tracing?
+
+    ::Instana.tracer.start_or_continue_trace(:rack, {:one => 1}) do
+      assert_equal false, ::Instana.tracer.tracing?
+    end
+
+    ::Instana.config[:tracing][:enabled] = true
+  end
+
+
+  def test_basic_trace_block
+    clear_all!
+
+    assert_equal false, ::Instana.tracer.tracing?
+
+    ::Instana.tracer.start_or_continue_trace(:rack, {:one => 1}) do
+      assert_equal true, ::Instana.tracer.tracing?
+      sleep 0.1
+    end
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.length
+
+    first_span = spans.first
+    assert_equal :rack, first_span[:n]
+    assert first_span[:ts].is_a?(Integer)
+    assert first_span[:d].is_a?(Integer)
+    assert first_span[:d].between?(100, 130)
+    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_errors_are_properly_propagated
+    clear_all!
+    exception_raised = false
+    begin
+      ::Instana.tracer.start_or_continue_trace(:rack, {:one => 1}) do
+        raise Exception.new('Error in block - this should continue to propogate outside of tracing')
+      end
+    rescue Exception
+      exception_raised = true
+    end
+
+    assert exception_raised
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.length
+
+    first_span = spans.first
+    assert_equal :rack, first_span[:n]
+    assert first_span[:ts].is_a?(Integer)
+    assert first_span[:ts] > 0
+    assert first_span[:d].is_a?(Integer)
+    assert first_span[:d].between?(0, 5)
+    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]
+    assert_equal first_span[:error], true
+    assert_equal first_span[:ec], 1
+  end
+
+  def test_complex_trace_block
+    clear_all!
+    ::Instana.tracer.start_or_continue_trace(:rack, {:one => 1}) do
+      sleep 0.2
+      ::Instana.tracer.trace(:sub_block, {:sub_two => 2}) do
+        sleep 0.2
+      end
+    end
+
+    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
+    clear_all!
+
+    assert_equal false, ::Instana.tracer.tracing?
+    # Start tracing
+    ::Instana.tracer.log_start_or_continue(:rack, {:one => 1})
+    assert_equal true, ::Instana.tracer.tracing?
+    ::Instana.tracer.log_info({:info_logged => 1})
+    # End tracing
+    ::Instana.tracer.log_end(:rack, {:close_one => 1})
+    assert_equal false, ::Instana.tracer.tracing?
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.length
+  end
+
+  def test_complex_low_level_tracing
+    clear_all!
+
+    assert_equal false, ::Instana.tracer.tracing?
+
+    # Start tracing
+    ::Instana.tracer.log_start_or_continue(:rack, {:one => 1})
+    assert_equal true, ::Instana.tracer.tracing?
+    ::Instana.tracer.log_info({:info_logged => 1})
+
+    # Start tracing a sub span
+    ::Instana.tracer.log_entry(:sub_task)
+    assert_equal true, ::Instana.tracer.tracing?
+    ::Instana.tracer.log_info({:sub_task_info => 1})
+    # Exit from the sub span
+    ::Instana.tracer.log_exit(:sub_task, {:sub_task_exit_info => 1})
+    assert_equal true, ::Instana.tracer.tracing?
+
+    # End tracing
+    ::Instana.tracer.log_end(:rack, {:close_one => 1})
+    assert_equal false, ::Instana.tracer.tracing?
+
+    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_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
+
+  end
+
+  def test_block_tracing_error_capture
+    clear_all!
+    exception_raised = false
+    begin
+      ::Instana.tracer.start_or_continue_trace(:test_trace, {:one => 1}) do
+        raise Exception.new("Block exception test error")
+      end
+    rescue Exception
+      exception_raised = true
+    end
+
+    assert exception_raised
+
+    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[:error], true
+    assert_equal sdk_span[:ec], 1
+    assert_equal sdk_span.key?(:stack), true
+  end
+
+  def test_low_level_error_logging
+    clear_all!
+    ::Instana.tracer.log_start_or_continue(:test_trace, {:one => 1})
+    ::Instana.tracer.log_info({:info_logged => 1})
+    ::Instana.tracer.log_error(Exception.new("Low level tracing api error"))
+    ::Instana.tracer.log_end(:test_trace, {:close_one => 1})
+
+    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