instana 1.217.1 → 2.1.0

data/test/tracing/opentracing_test.rb

@@ -1,382 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2017
-
-require 'test_helper'
-require 'rack/test'
-
-if Rack.release >= '3.0.0'
-  require 'rackup/lobster'
-else
-  require 'rack/lobster'
-end
-
-require "opentracing"
-
-module Instana
-  class OTRack1
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      otrack1_span = OpenTracing.start_span(:otrack1)
-      result = @app.call(env)
-      otrack1_span.finish
-      result
-    end
-  end
-
-  class OTRack2
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      otrack2_span = OpenTracing.start_span(:otrack2)
-      result = @app.call(env)
-      otrack2_span.finish
-      result
-    end
-  end
-end
-
-class OpenTracerTest < Minitest::Test
-  include Rack::Test::Methods
-
-  def app
-    @app = Rack::Builder.new {
-      use Instana::Rack
-      use Instana::OTRack1
-      use Rack::CommonLogger
-      use Rack::ShowExceptions
-      use Instana::OTRack2
-      map "/mrlobster" do
-        if Rack.release >= '3.0.0'
-          run Rackup::Lobster.new
-        else
-          run Rack::Lobster.new
-        end
-      end
-    }
-  end
-
-  def test_supplies_all_ot_interfaces
-    clear_all!
-    assert defined?(OpenTracing)
-    assert OpenTracing.respond_to?(:global_tracer)
-    assert OpenTracing.global_tracer.respond_to?(:start_span)
-    assert OpenTracing.global_tracer.respond_to?(:inject)
-    assert OpenTracing.global_tracer.respond_to?(:extract)
-
-    assert OpenTracing.respond_to?(:start_span)
-
-    assert defined?(OpenTracing::Carrier)
-    carrier = OpenTracing::Carrier.new
-    assert carrier.respond_to?(:[])
-    assert carrier.respond_to?(:[]=)
-    assert carrier.respond_to?(:each)
-
-    span = OpenTracing.start_span(:blah)
-    assert span.respond_to?(:finish)
-    assert span.respond_to?(:set_tag)
-    assert span.respond_to?(:tags)
-    assert span.respond_to?(:operation_name=)
-    assert span.respond_to?(:set_baggage_item)
-    assert span.respond_to?(:get_baggage_item)
-    assert span.respond_to?(:context)
-    assert span.respond_to?(:log)
-  end
-
-  def test_basic_get_with_opentracing
-    clear_all!
-    get '/mrlobster'
-    assert last_response.ok?
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 3, spans.length
-
-    first_span = find_first_span_by_name(spans, :rack)
-    second_span = find_first_span_by_name(spans, :otrack1)
-    third_span = find_first_span_by_name(spans, :otrack2)
-
-    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 first_span[:data].key?(:http)
-    assert_equal "GET", first_span[:data][:http][:method]
-    assert_equal "/mrlobster", first_span[:data][:http][:url]
-    assert_equal 200, first_span[:data][:http][:status]
-    assert_equal 'example.org', first_span[:data][:http][:host]
-    assert_equal :otrack1, second_span[:data][:sdk][:name]
-    assert second_span.key?(:data)
-    assert second_span[:data].key?(:sdk)
-    assert second_span[:data][:sdk].key?(:name)
-    assert_equal :otrack2, third_span[:data][:sdk][:name]
-    assert third_span.key?(:data)
-    assert third_span[:data].key?(:sdk)
-    assert third_span[:data][:sdk].key?(:name)
-
-    # ID Validation
-    refute_equal first_span[:t], second_span[:t]
-    refute_equal second_span[:t], third_span[:t]
-  end
-
-  def test_get_with_inject_extract
-    clear_all!
-
-    trace_id = ::Instana::Util.generate_id
-    span_id = ::Instana::Util.generate_id
-
-    header 'X-Instana-T', ::Instana::Util.id_to_header(trace_id)
-    header 'X-Instana-S', ::Instana::Util.id_to_header(span_id)
-
-    get '/mrlobster'
-    assert last_response.ok?
-
-    spans = ::Instana.processor.queued_spans
-
-    assert_equal 3, spans.length
-    first_span = find_first_span_by_name(spans, :rack)
-
-    # Make sure context was picked up and continued in the resulting
-    # trace
-    assert_equal trace_id, first_span[:t]
-    assert_equal span_id, first_span[:p]
-  end
-
-  def test_start_span_with_tags
-    clear_all!
-    span = OpenTracing.start_span('my_app_entry')
-
-    assert span.is_a?(::Instana::Span)
-
-    span.set_tag(:tag_integer, 1234)
-    span.set_tag(:tag_boolean, true)
-    span.set_tag(:tag_array, [1,2,3,4])
-    span.set_tag(:tag_string, "1234")
-
-    assert_equal 1234, span.tags(:tag_integer)
-    assert_equal true, span.tags(:tag_boolean)
-    assert_equal [1,2,3,4], span.tags(:tag_array)
-    assert_equal "1234", span.tags(:tag_string)
-    span.finish
-  end
-
-  def test_start_span_with_custom_start_time
-    clear_all!
-    now = Time.now
-    now_in_ms = ::Instana::Util.time_to_ms(now)
-
-    span = OpenTracing.start_span('my_app_entry', :start_time => now)
-
-    assert span.is_a?(::Instana::Span)
-
-    span.set_tag(:tag_integer, 1234)
-    span.set_tag(:tag_boolean, true)
-    span.set_tag(:tag_array, [1,2,3,4])
-    span.set_tag(:tag_string, "1234")
-
-    assert_equal 1234, span.tags(:tag_integer)
-    assert_equal true, span.tags(:tag_boolean)
-    assert_equal [1,2,3,4], span.tags(:tag_array)
-    assert_equal "1234", span.tags(:tag_string)
-    span.finish
-
-    assert span[:ts].is_a?(Integer)
-    assert_equal now_in_ms, span[:ts]
-    assert span[:d].is_a?(Integer)
-    assert span[:d].between?(0, 5)
-  end
-
-  def test_span_kind_translation
-    clear_all!
-    span = OpenTracing.start_span('my_app_entry')
-
-    assert span.is_a?(::Instana::Span)
-
-    span.set_tag(:'span.kind', :server)
-    assert_equal :entry, span[:data][:sdk][:type]
-    assert_equal 1, span[:k]
-
-    span.set_tag(:'span.kind', :consumer)
-    assert_equal :entry, span[:data][:sdk][:type]
-    assert_equal 1, span[:k]
-
-    span.set_tag(:'span.kind', :client)
-    assert_equal :exit, span[:data][:sdk][:type]
-    assert_equal 2, span[:k]
-
-    span.set_tag(:'span.kind', :producer)
-    assert_equal :exit, span[:data][:sdk][:type]
-    assert_equal 2, span[:k]
-
-    span[:data][:sdk].delete(:type)
-    span.set_tag(:'span.kind', :blah)
-    assert_equal :intermediate, span[:data][:sdk][:type]
-    assert_equal 3, span[:k]
-    assert_equal :blah, span[:data][:sdk][:custom][:tags][:'span.kind']
-
-    span.finish
-  end
-
-  def test_start_span_with_baggage
-    clear_all!
-    span = OpenTracing.start_span('my_app_entry')
-    span.set_baggage_item(:baggage_integer, 1234)
-    span.set_baggage_item(:baggage_boolean, false)
-    span.set_baggage_item(:baggage_array, [1,2,3,4])
-    span.set_baggage_item(:baggage_string, '1234')
-
-    assert_equal 1234, span.get_baggage_item(:baggage_integer)
-    assert_equal false, span.get_baggage_item(:baggage_boolean)
-    assert_equal [1,2,3,4], span.get_baggage_item(:baggage_array)
-    assert_equal "1234", span.get_baggage_item(:baggage_string)
-    span.finish
-  end
-
-  def test_start_span_with_timestamps
-    clear_all!
-    span_tags = {:start_tag => 1234, :another_tag => 'tag_value'}
-
-    ts_start = Time.now - 1 # Put start time a bit in the past
-    ts_start_ms = ::Instana::Util.time_to_ms(ts_start)
-
-    span = OpenTracing.start_span('my_app_entry', tags: span_tags, start_time: ts_start)
-    sleep 0.1
-
-    ts_finish = Time.now + 5 # Put end time in the future
-    ts_finish_ms = ::Instana::Util.time_to_ms(ts_finish)
-
-    span.finish(ts_finish)
-
-    assert_equal ts_start_ms, span[:ts]
-    assert_equal (ts_finish_ms - ts_start_ms), span[:d]
-
-    assert_equal 1234, span[:data][:sdk][:custom][:tags][:start_tag]
-    assert_equal 'tag_value', span[:data][:sdk][:custom][:tags][:another_tag]
-  end
-
-  def test_nested_spans_using_child_of
-    clear_all!
-    entry_span = OpenTracing.start_span(:rack)
-    ac_span = OpenTracing.start_span(:action_controller, child_of: entry_span)
-    av_span = OpenTracing.start_span(:action_view, child_of: ac_span)
-    sleep 0.1
-    av_span.finish
-    ac_span.finish
-    entry_span.finish
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 3, spans.length
-
-    first_span = find_first_span_by_name(spans, :rack)
-    second_span = find_first_span_by_name(spans, :action_controller)
-    third_span = find_first_span_by_name(spans, :action_view)
-
-    # IDs
-    assert_equal first_span[:t], second_span[:t]
-    assert_equal second_span[:t], third_span[:t]
-
-    # Linkage
-    assert first_span[:p].nil?
-    assert_equal first_span[:s], second_span[:p]
-    assert_equal second_span[:s], third_span[:p]
-  end
-
-  def test_nested_spans_with_baggage
-    clear_all!
-    entry_span = OpenTracing.start_span(:rack)
-    ac_span = OpenTracing.start_span(:action_controller, child_of: entry_span)
-    ac_span.set_baggage_item(:my_bag, 1)
-    av_span = OpenTracing.start_span(:action_view, child_of: ac_span)
-    sleep 0.1
-    av_span.finish
-    ac_span.finish
-    entry_span.finish
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 3, spans.length
-
-    first_span = find_first_span_by_name(spans, :rack)
-    second_span = find_first_span_by_name(spans, :action_controller)
-    third_span = find_first_span_by_name(spans, :action_view)
-
-    # IDs
-    assert_equal first_span[:t], second_span[:t]
-    assert_equal second_span[:t], third_span[:t]
-
-    # Linkage
-    assert first_span[:p].nil?
-    assert_equal first_span[:s], second_span[:p]
-    assert_equal second_span[:s], third_span[:p]
-
-    # Every span should have baggage
-    assert_equal({}, entry_span.context.baggage)
-    assert_equal({:my_bag=>1}, ac_span.context.baggage)
-    assert_equal({:my_bag=>1}, av_span.context.baggage)
-  end
-
-  def test_context_should_carry_baggage
-    clear_all!
-
-    entry_span = OpenTracing.start_span(:rack)
-    entry_span_context = entry_span.context
-
-    ac_span = OpenTracing.start_span(:action_controller, child_of: entry_span)
-    ac_span.set_baggage_item(:my_bag, 1)
-    ac_span_context = ac_span.context
-
-    av_span = OpenTracing.start_span(:action_view, child_of: entry_span)
-    av_span_context = av_span.context
-
-    sleep 0.1
-
-    av_span.finish
-    ac_span.finish
-    entry_span.finish
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 3, spans.length
-
-    assert_equal({}, entry_span.context.baggage)
-    assert_equal({:my_bag=>1}, ac_span.context.baggage)
-    assert_equal({}, av_span.context.baggage)
-  end
-
-  def test_start_active_span
-    clear_all!
-
-    span = OpenTracing.start_active_span(:rack)
-    assert_equal ::Instana::Tracer.current_span, span
-
-    sleep 0.1
-
-    span.finish
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 1, spans.length
-  end
-
-  def test_active_span
-    clear_all!
-
-    span = OpenTracing.start_active_span(:rack)
-    assert_equal OpenTracing.active_span, span
-  end
-
-  def test_active_span_block
-    clear_all!
-
-    obj = OpenTracing.start_active_span(:rack) { 1 }
-    assert_equal 1, obj
-  end
-
-  def test_span_rename
-    span = OpenTracing.start_active_span(:rack)
-    span.operation_name = 'test'
-    assert_equal 'test', span.name
-  end
-end

data/test/tracing/processor_test.rb

@@ -1,58 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2021
-
-require 'test_helper'
-
-class ProcessorTest < Minitest::Test
-  def test_queued_spans_empty
-    subject = Instana::Processor.new
-    assert_equal [], subject.queued_spans
-  end
-
-  def test_queued_spans_valid_level
-    clear_all!
-    subject = Instana::Processor.new
-
-    span_context = Instana::SpanContext.new('9', '8', 0)
-    span = Instana::Span.new(:rack, parent_ctx: span_context)
-    span2 = Instana::Span.new(:"net-http")
-
-    subject.add_span(span)
-    subject.add_span(span2)
-
-    spans = subject.queued_spans
-    valid_span, = spans
-
-    assert_equal 1, spans.length
-    assert_equal :"net-http", valid_span[:n]
-  end
-
-  def test_queued_spans_invalid_type
-    subject = Instana::Processor.new
-    subject.add_span(false)
-
-    assert_equal [], subject.queued_spans
-  end
-
-  def test_send
-    ENV['INSTANA_TEST'] = nil
-
-    subject = Instana::Processor.new
-    span = Instana::Span.new(:rack)
-    subject.add_span(span)
-
-    was_invoked = false
-
-    subject.send do |spans|
-      was_invoked = true
-      rack_span, = spans
-
-      assert_equal 1, spans.length
-      assert_equal :rack, rack_span[:n]
-    end
-
-    assert was_invoked
-  ensure
-    ENV['INSTANA_TEST'] = 'true'
-  end
-end

data/test/tracing/span_context_test.rb

@@ -1,22 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2021
-
-require 'test_helper'
-
-class SpanContextTest < Minitest::Test
-  def test_to_hash
-    subject = Instana::SpanContext.new('trace', 'span')
-    assert_equal({trace_id: 'trace', span_id: 'span'}, subject.to_hash)
-  end
-
-  def test_invalid
-    subject = Instana::SpanContext.new(nil, nil)
-    refute subject.valid?
-  end
-
-  def test_flags_level_zero
-    subject = Instana::SpanContext.new('trace', 'span', 0, {external_state: 'cn=test'})
-    assert_equal '00-000000000000000000000000000trace-000000000000span-00', subject.trace_parent_header
-    assert_equal 'cn=test', subject.trace_state_header
-  end
-end

data/test/tracing/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('test', 'test', 0)
-    span = Instana::Span.new(:test, parent_ctx: context)
-
-    assert_equal 'test', span.parent_id
-    assert_equal 'test', span.trace_id
-  end
-
-  def test_span_from_contetx_invalid
-    context = Instana::SpanContext.new(nil, nil, 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.add_error(StandardError.new('Test1'))
-    span.add_error(StandardError.new('Test2'))
-
-    assert_equal 2, span[:ec]
-    assert_equal 'Test2', span[:data][:activerecord][:error]
-  end
-
-  def test_add_error_nil
-    span = Instana::Span.new(:activerecord)
-    span.add_error(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