instana 1.217.1 → 2.1.0

data/test/tracing/tracer_async_test.rb

@@ -1,230 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2016
-
-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
-
-  def test_async_helpers
-    clear_all!
-    ::Instana.tracer.log_start_or_continue(:rack)
-
-    span = ::Instana.tracer.log_async_entry(:async, {})
-    ::Instana.tracer.log_async_info({a: 1}, span)
-    ::Instana.tracer.log_async_error(StandardError.new('Error'), span)
-    ::Instana.tracer.log_async_exit(nil, {}, span)
-
-    spans = ::Instana.processor.queued_spans
-    span, = spans
-
-    assert_equal({a: 1}, span[:data][:sdk][:custom][:tags])
-    assert_equal(1, span[:ec])
-  end
-
-  def test_async_helpers_tag_exit
-    clear_all!
-    ::Instana.tracer.log_start_or_continue(:rack)
-
-    span = ::Instana.tracer.log_async_entry(:async, {})
-    ::Instana.tracer.log_async_exit(nil, {a: 1}, span)
-
-    spans = ::Instana.processor.queued_spans
-    span, = spans
-
-    assert_equal({a: 1}, span[:data][:sdk][:custom][:tags])
-  end
-end

data/test/tracing/tracer_test.rb

@@ -1,352 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2016
-
-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_equal ::Instana.agent.source, first_span[:f]
-  end
-
-  def test_exotic_tag_types
-    clear_all!
-
-    assert_equal false, ::Instana.tracer.tracing?
-
-    ipv4 = '111.111.111.111'
-
-    ::Instana.tracer.start_or_continue_trace(:rack, {:ipaddr => ipv4}) 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 first_span[:data].key?(:ipaddr)
-    assert first_span[:data][:ipaddr].is_a?(String)
-    assert first_span.key?(:f)
-    assert_equal ::Instana.agent.source, first_span[:f]
-  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_equal ::Instana.agent.source, first_span[:f]
-    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_nil rack_span[:p]
-    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_custom_complex_trace_block
-    clear_all!
-    ::Instana.tracer.start_or_continue_trace(:root_span, {:one => 1}) do
-      sleep 0.2
-      ::Instana.tracer.trace(:sub_span, {:sub_two => 2}) do
-        sleep 0.2
-      end
-    end
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    root_span = find_first_span_by_name(spans, :root_span)
-    sub_span = find_first_span_by_name(spans, :sub_span)
-
-    assert_equal root_span[:n], :sdk
-    assert_equal root_span[:data][:sdk][:name], :root_span
-    assert_equal root_span[:data][:sdk][:type], :entry
-    assert_equal root_span[:k], 1
-    assert_nil root_span[:p]
-    assert_equal root_span[:t], root_span[:s]
-    assert_equal root_span[:data][:sdk][:custom][:tags][:one], 1
-
-    assert_equal sub_span[:n], :sdk
-    assert_equal sub_span[:data][:sdk][:name], :sub_span
-    assert_equal sub_span[:data][:sdk][:type], :intermediate
-    assert_equal sub_span[:k], 3
-    assert_equal sub_span[:p], root_span[:s]
-    assert_equal sub_span[:t], root_span[:t]
-    assert_equal sub_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_equal ::Instana.agent.source, rack_span[:f]
-
-    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
-        ::Instana.tracer.trace(:test_trace_two) do
-          raise Exception.new("Block exception test error")
-        end
-      end
-    rescue Exception
-      exception_raised = true
-    end
-
-    assert exception_raised
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    sdk_span = spans.last
-
-    assert_equal sdk_span[:n], :sdk
-    assert_equal sdk_span[:data][:sdk][:name], :test_trace
-    assert_equal sdk_span[:data][:sdk][:type], :entry
-    assert_equal sdk_span[:k], 1
-    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], :entry
-    assert_equal sdk_span[:k], 1
-    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
-
-  def test_nil_returns
-    clear_all!
-
-    refute ::Instana.tracer.tracing?
-    assert_nil ::Instana.tracer.log_entry(nil)
-    assert_nil ::Instana.tracer.log_info(nil)
-    assert_nil ::Instana.tracer.log_error(nil)
-    assert_nil ::Instana.tracer.log_exit(nil)
-    assert_nil ::Instana.tracer.log_end(nil)
-    assert_nil ::Instana.tracer.log_async_entry(nil, nil)
-    assert_nil ::Instana.tracer.context
-  end
-
-  def test_tracing_span
-    clear_all!
-
-    refute ::Instana.tracer.tracing_span?(:rack)
-    ::Instana.tracer.log_start_or_continue(:rack)
-    assert ::Instana.tracer.tracing_span?(:rack)
-  end
-
-  def test_log_exit_warn_span_name
-    logger = Minitest::Mock.new
-    logger.expect(:warn, true, [String])
-    subject = Instana::Tracer.new(logger: logger)
-
-    subject.log_start_or_continue(:sample)
-    subject.log_exit(:roda)
-
-    logger.verify
-  end
-
-  def test_log_end_warn_span_name
-    clear_all!
-
-    logger = Minitest::Mock.new
-    logger.expect(:warn, true, [String])
-    subject = Instana::Tracer.new(logger: logger)
-
-    subject.log_start_or_continue(:sample)
-    subject.log_end(:roda)
-
-    logger.verify
-  end
-
-  def test_log_entry_span
-    clear_all!
-
-    subject = Instana::Tracer.new
-    span = Instana::Span.new(:rack)
-
-    subject.log_entry(:sample, {}, ::Instana::Util.now_in_ms, span)
-    assert subject.tracing?
-    assert subject.current_span.parent, span
-  end
-
-  def test_log_entry_span_context
-    clear_all!
-
-    subject = Instana::Tracer.new
-    span_context = Instana::SpanContext.new('test', 'test')
-
-    subject.log_entry(:sample, {}, ::Instana::Util.now_in_ms, span_context)
-    assert subject.tracing?
-    assert subject.current_span.context, span_context
-  end
-
-  def test_missing_class_super
-    assert_raises NoMethodError do
-      Instana::Tracer.invalid
-    end
-  end
-end

data/test/util_test.rb

@@ -1,10 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2021
-
-require 'test_helper'
-
-class UtilTest < Minitest::Test
-  def test_get_rb_source_error
-    assert_equal({ error: "Only Ruby source files are allowed. (*.rb)" }, Instana::Util.get_rb_source('invalid.txt'))
-  end
-end