instana 2.0.0 → 2.2.0

data/test/trace/span_test.rb

@@ -1,179 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2021
-
-require 'test_helper'
-
-class SpanTest < Minitest::Test
-  def test_getters_setters
-    span = Instana::Span.new(:test)
-
-    assert_equal span[:s], span.id
-    assert_equal span[:t], span.trace_id
-    assert_nil span[:p] # parent_id of a root span is nil
-    assert_nil span[:d] # duration of an open span is nil
-
-    span.parent_id = 'test'
-    assert_equal 'test', span.parent_id
-
-    span.name = 'test'
-    assert_equal 'test', span[:data][:sdk][:name]
-
-    span[:t] = 'test'
-    assert span.key?(:t)
-    assert_equal 'test', span[:t]
-
-    assert span.inspect
-  end
-
-  def test_builtin_span_rename
-    span = Instana::Span.new(:"net-http")
-    assert_equal :"net-http", span.name
-
-    span.name = 'test'
-    assert_equal 'test', span.name
-  end
-
-  def test_exit_span
-    span = Instana::Span.new(:"net-http")
-    assert span.exit_span?
-  end
-
-  def test_span_from_contetx
-    context = Instana::SpanContext.new(trace_id: 'test', span_id: 'test', level: 0)
-    span = Instana::Span.new(:test, context)
-
-    assert_equal 'test', span.parent_id
-    assert_equal 'test', span.trace_id
-  end
-
-  def test_span_from_contetx_invalid
-    context = Instana::SpanContext.new(trace_id: nil, span_id: nil, level: 1)
-    span = Instana::Span.new(:test, parent_ctx: context)
-
-    assert_nil span.parent_id
-    refute_equal context.span_id, span.trace_id
-    assert_equal 1, span.context.level
-  end
-
-  def test_span_collect_backtraces
-    Instana.config[:collect_backtraces] = true
-    span = Instana::Span.new(:excon)
-    assert span[:stack]
-  ensure
-    Instana.config[:collect_backtraces] = false
-  end
-
-  def test_span_backtrace_cleaner
-    Instana.config[:collect_backtraces] = true
-    Instana.config[:backtrace_cleaner] =
-      ->(trace) { trace.filter { |line| line.include?("lib/instana") } }
-    span = Instana::Span.new(:excon)
-
-    assert_equal 1, span[:stack].size
-  ensure
-    Instana.config[:backtrace_cleaner] = nil
-    Instana.config[:collect_backtraces] = false
-  end
-
-  def test_span_stack_over_limit
-    def inner(depth = 50, &blk) # rubocop:disable Lint/NestedMethodDefinition
-      return blk.call if depth.zero?
-
-      inner(depth - 1, &blk)
-    end
-
-    inner do
-      span = Instana::Span.new(:excon)
-      span.add_stack(limit: 500)
-      assert_equal 40, span[:stack].length
-    end
-  end
-
-  def test_multiple_errors
-    span = Instana::Span.new(:activerecord)
-    span.set_tag(:activerecord, {})
-
-    span.record_exception(StandardError.new('Test1'))
-    span.record_exception(StandardError.new('Test2'))
-
-    assert_equal 2, span[:ec]
-    assert_equal 'Test2', span[:data][:activerecord][:error]
-  end
-
-  def test_record_exception_nil
-    span = Instana::Span.new(:activerecord)
-    span.record_exception(nil)
-
-    assert_equal 1, span[:ec]
-  end
-
-  def test_set_tag_merge
-    span = Instana::Span.new(:excon)
-    span.set_tag(1024, {a: 1})
-    span.set_tag(1024, {b: 2})
-
-    assert_equal({'1024' => {a: 1, b: 2}}, span[:data])
-  end
-
-  def test_set_tags_non_hash
-    span = Instana::Span.new(:excon)
-    assert_nil span.set_tags(0)
-  end
-
-  def test_tags_standard
-    span = Instana::Span.new(:excon)
-    span.set_tag(:test, {a: 1})
-
-    assert_equal({test: {a: 1}}, span.tags)
-    assert_equal({a: 1}, span.tags(:test))
-  end
-
-  def test_log_standard
-    span = Instana::Span.new(:excon)
-    span.log(:test, Time.now, a: 1)
-
-    assert_equal({log: {a: 1}}, span.tags)
-  end
-
-  def test_log_error
-    time = Minitest::Mock.new
-    time.expect(:to_f, nil)
-
-    span = Instana::Span.new(:sdk)
-    span.log(:test, time, a: 1)
-
-    assert_equal({}, span.tags)
-    time.verify
-  end
-
-  def test_inc_processed_counts
-    clear_all!
-
-    span = Instana::Span.new(:excon)
-    span.close
-
-    metrics = Instana.processor.span_metrics
-
-    assert_equal 1, metrics[:opened]
-    assert_equal 1, metrics[:closed]
-
-    metrics = Instana.processor.span_metrics
-
-    assert_equal 0, metrics[:opened]
-    assert_equal 0, metrics[:closed]
-  end
-
-  def test_custom_service_name_set
-    service_name = 'MyVeryCustomRubyServiceNameForInstanaTesting'
-    ENV['INSTANA_SERVICE_NAME'] = service_name
-    span = Instana::Span.new(:excon)
-    assert_equal(service_name, span[:data][:service])
-  ensure
-    ENV.delete('INSTANA_SERVICE_NAME')
-  end
-
-  def test_no_custom_service_name_set
-    span = Instana::Span.new(:excon)
-    assert_nil(span[:data][:service])
-  end
-end

data/test/trace/tracer_async_test.rb

@@ -1,243 +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.start_span(:rack, attributes: {: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
-    span = ::Instana.tracer.start_span(:rack, attributes: {:rack_start_kv => 1})
-
-    t_context = ::Instana.tracer.context
-    refute_nil t_context.trace_id
-    refute_nil t_context.span_id
-
-    Thread.new do
-      span1 = ::Instana::Trace.with_span(OpenTelemetry::Trace.non_recording_span(t_context)) do
-        ::Instana.tracer.start_span(:async_thread, attributes: { :async_start => 1 })
-      end
-      span2 = ::Instana::Trace.with_span(span1) do
-        ::Instana.tracer.start_span(:sleepy_time, attributes: { :tired => 1 })
-      end
-
-      # Sleep beyond the end of this root trace
-      sleep 0.5
-      span2.set_tags({ :wake_up => 1})
-      span2.finish
-      span1.set_tags({:async_end => 1})
-      span1.finish
-    end
-    # Current span should still be rack
-    assert_equal :rack, ::Instana.tracer.current_span.name
-    span.set_tags({:rack_end_kv => 1})
-    span.finish
-    # 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
-    span = ::Instana.tracer.start_span(:rack, attributes: {:rack_start_kv => 1})
-
-    # Start three asynchronous spans
-    span1, span2, span3 = ::Instana::Trace.with_span(span) do
-      span1 = ::Instana.tracer.start_span(:my_async_op1, attributes: { :entry_kv => 1})
-      span2 = ::Instana.tracer.start_span(:my_async_op2, attributes: { :entry_kv => 2})
-      span3 = ::Instana.tracer.start_span(:my_async_op3, attributes: { :entry_kv => 3})
-      return span1, span2, span3
-    end
-
-    # Context awareness when using Opentelemetry is done through Opentelemetry::Context so the below test is invalid
-    # 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.record_exception(Exception.new("Async span 3"))
-    span2.record_exception(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
-
-    # Context awareness when using Opentelemetry is done through Opentelemetry::Context so the below test is invalid
-    # Current span should still be rack
-    # assert_equal :rack, ::Instana.tracer.current_span.name
-
-    # End tracing
-    span.set_tags({:rack_end_kv => 1})
-    span.finish
-
-    # Log an error to and close out the remaining async span after the parent trace has finished
-    span1.record_exception(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.start_span(:rack)
-
-    span1 = ::Instana.tracer.start_span(:async, attributes: {})
-    span1.set_tags({a: 1})
-    span1.record_exception(StandardError.new('Error'))
-    span1.finish
-
-    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.start_span(:rack)
-
-    span1 = ::Instana.tracer.start_span(:async, attributes: {})
-    span1.set_tags({a: 1})
-    span1.finish
-
-    spans = ::Instana.processor.queued_spans
-    span, = spans
-
-    assert_equal({a: 1}, span[:data][:sdk][:custom][:tags])
-  end
-end

data/test/trace/tracer_provider_test.rb

@@ -1,148 +0,0 @@
-# (c) Copyright IBM Corp. 2025
-# (c) Copyright Instana Inc. 2025
-
-require 'test_helper'
-require 'instana/trace/tracer_provider'
-require 'instana/trace/export'
-
-class TracerProviderTest < Minitest::Test
-  def setup
-    @tracer_provider = Instana.tracer_provider
-  end
-
-  def test_tracer
-    # This tests the global tracer is the same as tracer from tracer_provider
-    assert_equal Instana.tracer, @tracer_provider.tracer("instana_tracer")
-  end
-
-  def test_shutdown_with_timeout
-    @tracer_provider = ::Instana::Trace::TracerProvider.new
-    @tracer_provider.add_span_processor(DummyProcessor.new)
-    timeout = 10
-    result = @tracer_provider.shutdown(timeout: timeout)
-    assert_equal Instana::Trace::Export::SUCCESS, result
-    @span_processors = @tracer_provider.instance_variable_get(:@span_processors)
-    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
-    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
-    assert @tracer_provider.instance_variable_get(:@stopped)
-  end
-
-  def test_shutdown_without_timeout
-    @tracer_provider = ::Instana::Trace::TracerProvider.new
-    @tracer_provider.add_span_processor(DummyProcessor.new)
-    # @tracer = @tracer_provider.tracer('test_shutdown_without_timeout')
-    result = @tracer_provider.shutdown
-    assert_equal Instana::Trace::Export::SUCCESS, result
-
-    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
-    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
-    assert @tracer_provider.instance_variable_get(:@stopped)
-  end
-
-  def test_shutdown_called_multiple_times
-    @tracer_provider = ::Instana::Trace::TracerProvider.new
-    @tracer_provider.add_span_processor(DummyProcessor.new)
-    # @tracer = @tracer_provider.tracer('test_shutdown_called_multiple_times')
-
-    result1 = @tracer_provider.shutdown
-    result2 = @tracer_provider.shutdown
-
-    assert_equal Instana::Trace::Export::SUCCESS, result1
-    assert_equal Instana::Trace::Export::FAILURE, result2
-
-    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
-    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
-    assert @tracer_provider.instance_variable_get(:@stopped)
-  end
-
-  def test_shutdown_with_zero_timeout
-    @tracer_provider = ::Instana::Trace::TracerProvider.new
-    @tracer_provider.add_span_processor(DummyProcessor.new)
-    # @tracer = @tracer_provider.tracer('test_shutdown_with_zero_timeout')
-    timeout = 0
-    result = @tracer_provider.shutdown(timeout: timeout)
-    assert_equal Instana::Trace::Export::TIMEOUT, result
-
-    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
-    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
-    assert @tracer_provider.instance_variable_get(:@stopped)
-  end
-
-  def test_force_flush_with_timeout
-    @tracer_provider = ::Instana::Trace::TracerProvider.new
-    @tracer_provider.add_span_processor(DummyProcessor.new)
-    timeout = 10
-    result = @tracer_provider.force_flush(timeout: timeout)
-    assert_equal Instana::Trace::Export::SUCCESS, result
-    @span_processors = @tracer_provider.instance_variable_get(:@span_processors)
-    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
-    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
-  end
-
-  def test_force_flush_without_timeout
-    @tracer_provider = ::Instana::Trace::TracerProvider.new
-    @tracer_provider.add_span_processor(DummyProcessor.new)
-    result = @tracer_provider.force_flush
-    assert_equal Instana::Trace::Export::SUCCESS, result
-
-    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
-    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
-  end
-
-  def test_force_flush_with_zero_timeout
-    @tracer_provider = ::Instana::Trace::TracerProvider.new
-    @tracer_provider.add_span_processor(DummyProcessor.new)
-    timeout = 0
-    result = @tracer_provider.force_flush(timeout: timeout)
-    assert_equal Instana::Trace::Export::TIMEOUT, result
-
-    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
-    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
-  end
-
-  def test_add_span_processor_after_shutdown
-    @tracer_provider = ::Instana::Trace::TracerProvider.new
-    @tracer_provider.add_span_processor(DummyProcessor.new)
-    @tracer_provider.shutdown
-    result = @tracer_provider.add_span_processor(DummyProcessor.new)
-    assert_nil result
-    # No new span processor was added as tracer_provider is stopped
-    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
-  end
-
-  def test_internal_start_span_untraced
-    @tracer_provider = ::Instana::Trace::TracerProvider.new
-    Minitest::Mock.new
-    result = @tracer_provider.internal_start_span('test_span', 'kind', {}, [], Time.now, nil, @instrumentation_scope)
-    assert_instance_of(Instana::Span, result)
-    # Todo add proper testcase
-  end
-
-  def test_internal_start_span_traced
-    @tracer_provider = ::Instana::Trace::TracerProvider.new
-    Minitest::Mock.new
-    result = @tracer_provider.internal_start_span('test_span', 'kind', {}, [], Time.now, nil, @instrumentation_scope)
-    assert_instance_of(Instana::Span, result)
-    # Todo add proper testcase
-  end
-
-  def test_internal_start_span_stopped
-    @tracer_provider = ::Instana::Trace::TracerProvider.new
-    Minitest::Mock.new
-    result = @tracer_provider.internal_start_span('test_span', 'kind', {}, [], Time.now, nil, @instrumentation_scope)
-    assert_instance_of(Instana::Span, result)
-    # Todo add proper testcase
-  end
-end
-
-class DummyProcessor
-  def initialize; end
-
-  def shutdown(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
-    Instana::Trace::Export::SUCCESS
-  end
-
-  def force_flush(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
-    Instana::Trace::Export::SUCCESS
-  end
-end