instana 1.9.7 → 1.10.0.slimfast

data/test/jobs/resque_error_job.rb

@@ -5,7 +5,13 @@ class ErrorJob
   @queue = :critical
 
   def self.perform
-    redis = Redis.new(url: ENV['REDIS_URL'])
+    if ENV.key?('REDIS_URL')
+      redis = Redis.new(:url => ENV['REDIS_URL'])
+    elsif ENV.key?('I_REDIS_URL')
+      redis = Redis.new(:url => ENV['I_REDIS_URL'])
+    else
+      redis = Redis.new(:url => 'localhost:6379')
+    end
 
     dt = Time.now
     redis.set('ts', dt)

data/test/jobs/resque_fast_job.rb

@@ -5,7 +5,13 @@ class FastJob
   @queue = :critical
 
   def self.perform
-    redis = Redis.new(url: ENV['REDIS_URL'])
+    if ENV.key?('REDIS_URL')
+      redis = Redis.new(:url => ENV['REDIS_URL'])
+    elsif ENV.key?('I_REDIS_URL')
+      redis = Redis.new(:url => ENV['I_REDIS_URL'])
+    else
+      redis = Redis.new(:url => 'redis://localhost:6379')
+    end
 
     dt = Time.now
     redis.set('ts', dt)

data/test/servers/sidekiq/worker.rb

@@ -23,7 +23,5 @@ end
 Minitest.after_run do
   ::Instana.logger.info "Killing Sidekiq worker"
   sidekiq_thread[:worker].stop
-  sleep 2
+  sleep 1
 end
-
-sleep 5

data/test/test_helper.rb

@@ -85,3 +85,61 @@ def enable_redis_instrumentation
     alias call_pipeline call_pipeline_with_instana
   end
 end
+
+def validate_sdk_span(json_span, sdk_hash = {}, errored = false, ec = 1)
+  assert_equal :sdk, json_span[:n]
+  assert json_span.key?(:k)
+  assert json_span.key?(:d)
+  assert json_span.key?(:ts)
+
+  for k,v in sdk_hash
+    assert_equal v, json_span[:data][:sdk][k]
+  end
+
+  if errored
+    assert_equal true, json_span[:error]
+    assert_equal 1, json_span[:ec]
+  end
+end
+
+def find_spans_by_name(spans, name)
+  result = []
+  for span in spans
+    if span[:n] == :sdk
+      if span[:data][:sdk][:name] == name
+        result << span
+      end
+    elsif span[:n] == name
+      result << span
+    end
+  end
+  if result.empty?
+    raise Exception.new("No SDK spans (#{name}) could be found")
+  else
+    return result
+  end
+end
+
+def find_first_span_by_name(spans, name)
+  for span in spans
+    if span[:n] == :sdk
+      if span[:data][:sdk][:name] == name
+        return span
+      end
+    else
+      if span[:n] == name
+        return span
+      end
+    end
+  end
+  raise Exception.new("Span (#{name}) not found")
+end
+
+def find_span_by_id(spans, id)
+  for span in spans
+    if span[:s] == id
+      return span
+    end
+  end
+  raise Exception.new("Span with id (#{id}) not found")
+end

data/test/tracing/custom_test.rb

@@ -13,13 +13,10 @@ class CustomTracingTest < Minitest::Test
     ::Instana.tracer.log_end(:custom_trace, {:close_one => 1})
     assert_equal false, ::Instana.tracer.tracing?
 
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    t = traces.first
-    assert_equal 1, t.spans.size
-    assert t.valid?
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.length
 
-    first_span = t.spans.first
+    first_span = spans.first
     assert_equal :sdk, first_span[:n]
 
     assert first_span[:ts].is_a?(Integer)
@@ -33,7 +30,6 @@ class CustomTracingTest < Minitest::Test
     assert first_span[:data][:sdk][:custom].key?(:tags)
     assert_equal :custom_trace, first_span[:data][:sdk][:name]
     assert_equal 1, first_span[:data][:sdk][:custom][:tags][:one]
-    assert_equal :ruby, first_span[:ta]
 
     assert first_span.key?(:f)
     assert first_span[:f].key?(:e)
@@ -62,13 +58,11 @@ class CustomTracingTest < Minitest::Test
     ::Instana.tracer.log_end(:rack, {:on_trace_end => 1})
     assert_equal false, ::Instana.tracer.tracing?
 
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    t = traces.first
-    assert_equal 2, t.spans.size
-    assert t.valid?
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
 
-    first_span, second_span = t.spans.to_a
+    first_span = find_first_span_by_name(spans, :rack)
+    second_span = find_first_span_by_name(spans, :custom_span)
 
     assert first_span[:ts].is_a?(Integer)
     assert first_span[:ts] > 0
@@ -121,13 +115,11 @@ class CustomTracingTest < Minitest::Test
     ::Instana.tracer.log_end(:rack, {:on_trace_end => 1})
     assert_equal false, ::Instana.tracer.tracing?
 
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    t = traces.first
-    assert_equal 2, t.spans.size
-    assert t.valid?
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
 
-    first_span, second_span = t.spans.to_a
+    first_span = find_first_span_by_name(spans, :rack)
+    second_span = find_first_span_by_name(spans, :custom_span)
 
     assert first_span[:ts].is_a?(Integer)
     assert first_span[:ts] > 0

data/test/tracing/opentracing_test.rb

@@ -79,17 +79,14 @@ class OpenTracerTest < Minitest::Test
     get '/mrlobster'
     assert last_response.ok?
 
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
 
-    trace = traces[0]
-    assert trace.valid?
+    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)
 
-    # Span validation
-    assert_equal 3, trace.spans.length
-    first_span, second_span, third_span = trace.spans.to_a
-
-    assert_equal :rack, first_span.name
+    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)
@@ -100,21 +97,18 @@ class OpenTracerTest < Minitest::Test
     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.name
+    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.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
-    assert_equal trace.id, first_span[:t]
-    assert_equal trace.id, third_span[:t]
-
-    # Linkage
-    assert_equal second_span[:s], third_span[:p]
+    refute_equal first_span[:t], second_span[:t]
+    refute_equal second_span[:t], third_span[:t]
   end
 
   def test_get_with_inject_extract
@@ -129,19 +123,14 @@ class OpenTracerTest < Minitest::Test
     get '/mrlobster'
     assert last_response.ok?
 
-    traces = ::Instana.processor.queued_traces
-    assert_equal 1, traces.length
-
-    trace = traces[0]
-    assert trace.valid?
+    spans = ::Instana.processor.queued_spans
 
-    # Span validation
-    assert_equal 3, trace.spans.length
-    first_span = trace.spans.to_a.first
+    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, trace.id
+    assert_equal trace_id, first_span[:t]
     assert_equal span_id, first_span[:p]
   end
 
@@ -150,7 +139,6 @@ class OpenTracerTest < Minitest::Test
     span = OpenTracing.start_span('my_app_entry')
 
     assert span.is_a?(::Instana::Span)
-    assert_equal :my_app_entry, OpenTracing.current_trace.current_span.name
 
     span.set_tag(:tag_integer, 1234)
     span.set_tag(:tag_boolean, true)
@@ -172,7 +160,6 @@ class OpenTracerTest < Minitest::Test
     span = OpenTracing.start_span('my_app_entry', :start_time => now)
 
     assert span.is_a?(::Instana::Span)
-    assert_equal :my_app_entry, OpenTracing.current_trace.current_span.name
 
     span.set_tag(:tag_integer, 1234)
     span.set_tag(:tag_boolean, true)
@@ -196,28 +183,27 @@ class OpenTracerTest < Minitest::Test
     span = OpenTracing.start_span('my_app_entry')
 
     assert span.is_a?(::Instana::Span)
-    assert_equal :my_app_entry, OpenTracing.current_trace.current_span.name
 
     span.set_tag(:'span.kind', :server)
     assert_equal :entry, span[:data][:sdk][:type]
-    assert_equal :entry, span[:k]
+    assert_equal 1, span[:k]
 
     span.set_tag(:'span.kind', :consumer)
     assert_equal :entry, span[:data][:sdk][:type]
-    assert_equal :entry, span[:k]
+    assert_equal 1, span[:k]
 
     span.set_tag(:'span.kind', :client)
     assert_equal :exit, span[:data][:sdk][:type]
-    assert_equal :exit, span[:k]
+    assert_equal 2, span[:k]
 
     span.set_tag(:'span.kind', :producer)
     assert_equal :exit, span[:data][:sdk][:type]
-    assert_equal :exit, span[:k]
+    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 :intermediate, span[:k]
+    assert_equal 3, span[:k]
     assert_equal :blah, span[:data][:sdk][:custom][:tags][:'span.kind']
 
     span.finish
@@ -270,53 +256,19 @@ class OpenTracerTest < Minitest::Test
     ac_span.finish
     entry_span.finish
 
-    traces = ::Instana.processor.queued_traces
-
-    assert_equal 1, traces.length
-
-    trace = traces.first
-    first_span, second_span, third_span = trace.spans.to_a
-
-    assert_equal 3, trace.spans.length
-    assert trace.valid?
-
-    # IDs
-    assert_equal trace.id, first_span[:t]
-    assert_equal trace.id, second_span[:t]
-    assert_equal trace.id, third_span[:t]
-
-    # Linkage
-    assert first_span.is_root?
-    assert_equal first_span[:s], second_span[:p]
-    assert_equal second_span[:s], third_span[:p]
-  end
-
-  def test_start_span_with_nested_spans
-    clear_all!
-    entry_span = OpenTracing.start_span(:rack)
-    ac_span = OpenTracing.start_span(:action_controller)
-    av_span = OpenTracing.start_span(:action_view)
-    sleep 0.1
-    av_span.finish
-    ac_span.finish
-    entry_span.finish
-
-    traces = ::Instana.processor.queued_traces
-
-    assert_equal 1, traces.length
-    trace = traces.first
-    assert trace.valid?
-    assert_equal 3, trace.spans.length
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
 
-    first_span, second_span, third_span = trace.spans.to_a
+    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 trace.id, first_span[:t]
-    assert_equal trace.id, second_span[:t]
-    assert_equal trace.id, third_span[:t]
+    assert_equal first_span[:t], second_span[:t]
+    assert_equal second_span[:t], third_span[:t]
 
     # Linkage
-    assert first_span.is_root?
+    assert first_span[:p].nil?
     assert_equal first_span[:s], second_span[:p]
     assert_equal second_span[:s], third_span[:p]
   end
@@ -324,37 +276,34 @@ class OpenTracerTest < Minitest::Test
   def test_nested_spans_with_baggage
     clear_all!
     entry_span = OpenTracing.start_span(:rack)
-    ac_span = OpenTracing.start_span(:action_controller)
+    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)
+    av_span = OpenTracing.start_span(:action_view, child_of: ac_span)
     sleep 0.1
     av_span.finish
     ac_span.finish
     entry_span.finish
 
-    traces = ::Instana.processor.queued_traces
-
-    assert_equal 1, traces.length
-    trace = traces.first
-    assert trace.valid?
-    assert_equal 3, trace.spans.length
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
 
-    first_span, second_span, third_span = trace.spans.to_a
+    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 trace.id, first_span[:t]
-    assert_equal trace.id, second_span[:t]
-    assert_equal trace.id, third_span[:t]
+    assert_equal first_span[:t], second_span[:t]
+    assert_equal second_span[:t], third_span[:t]
 
     # Linkage
-    assert first_span.is_root?
+    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, first_span.get_baggage_item(:my_bag)
-    assert_equal 1, second_span.get_baggage_item(:my_bag)
-    assert_equal 1, third_span.get_baggage_item(:my_bag)
+    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
@@ -363,81 +312,24 @@ class OpenTracerTest < Minitest::Test
     entry_span = OpenTracing.start_span(:rack)
     entry_span_context = entry_span.context
 
-    ac_span = OpenTracing.start_span(:action_controller)
+    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)
+    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
-
-    traces = ::Instana.processor.queued_traces
-
-    assert_equal 1, traces.length
-    trace = traces.first
-    assert trace.valid?
-    assert_equal 3, trace.spans.length
 
-    assert_equal nil, entry_span_context.baggage[:my_bag]
-    assert_equal 1, ac_span_context.baggage[:my_bag]
-    assert_equal 1, av_span_context.baggage[:my_bag]
-  end
-
-  def test_baggage_with_complex_data
-    clear_all!
-
-    entry_span = OpenTracing.start_span(:rack)
-    entry_span_context = entry_span.context
-
-    ac_span = OpenTracing.start_span(:action_controller)
-
-    ac_span.set_baggage_item(:integer, 1)
-    ac_span.set_baggage_item(:float, 1.0123948293)
-    ac_span.set_baggage_item(:hash, { :hash_sublevel => "blah",
-                                      :another => {} })
-    ac_span_context = ac_span.context
-
-    av_span = OpenTracing.start_span(:action_view)
-    av_span_context = av_span.context
-
-    sleep 0.1
     av_span.finish
     ac_span.finish
     entry_span.finish
 
-    traces = ::Instana.processor.queued_traces
-
-    assert_equal 1, traces.length
-    trace = traces.first
-    assert trace.valid?
-    assert_equal 3, trace.spans.length
-
-    # Context
-    assert_equal true, entry_span_context.baggage.empty?
-    assert_equal true, entry_span.baggage.empty?
-
-    assert_equal 1, ac_span_context.baggage[:integer]
-    assert_equal 1.0123948293, ac_span_context.baggage[:float]
-    assert_equal true, ac_span_context.baggage[:hash][:another].empty?
-    assert_equal "blah", ac_span_context.baggage[:hash][:hash_sublevel]
-    assert_equal 1, av_span_context.baggage[:integer]
-    assert_equal 1.0123948293, av_span_context.baggage[:float]
-    assert_equal true, av_span_context.baggage[:hash][:another].empty?
-    assert_equal "blah", av_span_context.baggage[:hash][:hash_sublevel]
-
-    # Spans
-    assert_equal true, entry_span.baggage.empty?
-    assert_equal 1, ac_span.baggage[:integer]
-    assert_equal 1.0123948293, ac_span.baggage[:float]
-    assert_equal true, ac_span.baggage[:hash][:another].empty?
-    assert_equal "blah", ac_span.baggage[:hash][:hash_sublevel]
-    assert_equal 1, av_span.baggage[:integer]
-    assert_equal 1.0123948293, av_span.baggage[:float]
-    assert_equal true, av_span.baggage[:hash][:another].empty?
-    assert_equal "blah", av_span.baggage[:hash][:hash_sublevel]
+    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