instana 1.10.1-java

data/test/tracing/id_management_test.rb

@@ -0,0 +1,130 @@
+
+require 'test_helper'
+
+class TracerIDMgmtTest < Minitest::Test
+  def test_id_to_header_conversion
+    # Test passing a standard Integer ID
+    original_id = ::Instana::Util.generate_id
+    converted_id = Instana::Util.id_to_header(original_id)
+
+    # Assert that it is a string and there are no non-hex characters
+    assert converted_id.is_a?(String)
+    assert !converted_id[/\H/]
+
+    # Test passing a standard Integer ID as a String
+    original_id = ::Instana::Util.generate_id
+    converted_id = Instana::Util.id_to_header(original_id)
+
+    # Assert that it is a string and there are no non-hex characters
+    assert converted_id.is_a?(String)
+    assert !converted_id[/\H/]
+  end
+
+  def test_id_to_header_conversion_with_bogus_id
+    # Test passing an empty String
+    converted_id = Instana::Util.id_to_header('')
+
+    # Assert that it is a string and there are no non-hex characters
+    assert converted_id.is_a?(String)
+    assert converted_id == ''
+
+    # Test passing a nil
+    converted_id = Instana::Util.id_to_header(nil)
+
+    # Assert that it is a string and there are no non-hex characters
+    assert converted_id.is_a?(String)
+    assert converted_id == ''
+
+    # Test passing an Array
+    converted_id = Instana::Util.id_to_header([])
+
+    # Assert that it is a string and there are no non-hex characters
+    assert converted_id.is_a?(String)
+    assert converted_id == ''
+  end
+
+  def test_header_to_id_conversion
+    # Get a hex string to test against & convert
+    header_id = Instana::Util.id_to_header(::Instana::Util.generate_id)
+    converted_id = Instana::Util.header_to_id(header_id)
+
+    # Assert that it is an Integer
+    assert converted_id.is_a?(Integer)
+  end
+
+  def test_header_to_id_conversion_with_bogus_header
+    # Bogus nil arg
+    bogus_result = Instana::Util.header_to_id(nil)
+    assert_equal 0, bogus_result
+
+    # Bogus Integer arg
+    bogus_result = Instana::Util.header_to_id(1234)
+    assert_equal 0, bogus_result
+
+    # Bogus Array arg
+    bogus_result = Instana::Util.header_to_id([1234])
+    assert_equal 0, bogus_result
+  end
+
+  def test_id_conversion_back_and_forth
+    # id --> header --> id
+    original_id = ::Instana::Util.generate_id
+    header_id = Instana::Util.id_to_header(original_id)
+    converted_back_id = Instana::Util.header_to_id(header_id)
+    assert original_id == converted_back_id
+
+    # header --> id --> header
+    original_header_id = "c025ee93b1aeda7b"
+    id = Instana::Util.header_to_id(original_header_id)
+    converted_back_header_id = Instana::Util.id_to_header(id)
+    assert_equal original_header_id, converted_back_header_id
+
+    # Test a random value
+    id = -7815363404733516491
+    header = "938a406416457535"
+
+    result = Instana::Util.header_to_id(header)
+    assert_equal id, result
+
+    result = Instana::Util.id_to_header(id)
+    assert_equal header, result
+
+    10000.times do
+      original_id = ::Instana::Util.generate_id
+      header_id = Instana::Util.id_to_header(original_id)
+      converted_back_id = Instana::Util.header_to_id(header_id)
+      assert original_id == converted_back_id
+    end
+  end
+
+  def test_id_max_value_and_conversion
+    max_id = 9223372036854775807
+    min_id = -9223372036854775808
+    max_hex = "7fffffffffffffff"
+    min_hex = "8000000000000000"
+
+    assert_equal max_hex, Instana::Util.id_to_header(max_id)
+    assert_equal min_hex, Instana::Util.id_to_header(min_id)
+
+    assert_equal max_id, Instana::Util.header_to_id(max_hex)
+    assert_equal min_id, Instana::Util.header_to_id(min_hex)
+  end
+
+  def test_that_leading_zeros_handled_correctly
+
+    header = ::Instana::Util.id_to_header(16)
+    assert_equal "10", header
+
+    id = ::Instana::Util.header_to_id("10")
+    assert_equal 16, id
+
+    id = ::Instana::Util.header_to_id("0000000000000010")
+    assert_equal 16, id
+
+    id = ::Instana::Util.header_to_id("88b6c735206ca42")
+    assert_equal 615705016619420226, id
+
+    id = ::Instana::Util.header_to_id("088b6c735206ca42")
+    assert_equal 615705016619420226, id
+  end
+end

data/test/tracing/opentracing_test.rb

@@ -0,0 +1,335 @@
+require 'test_helper'
+require 'rack/test'
+require 'rack/lobster'
+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
+
+OpenTracing.global_tracer = ::Instana.tracer
+
+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
+        run Rack::Lobster.new
+      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 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(nil, 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(nil, entry_span.context.baggage)
+    assert_equal({:my_bag=>1}, ac_span.context.baggage)
+    assert_equal(nil, av_span.context.baggage)
+  end
+end