instana 1.9.7 → 1.10.0.slimfast

data/test/frameworks/rails/activerecord5_test.rb

@@ -26,10 +26,10 @@ class ActiveRecordTest < Minitest::Test
     third_span = spans[3]
     fourth_span = spans[4]
 
-    assert_equal :rack, first_span.name
-    assert_equal :activerecord, second_span.name
-    assert_equal :activerecord, third_span.name
-    assert_equal :activerecord, fourth_span.name
+    assert_equal :rack, first_span[:n]
+    assert_equal :activerecord, second_span[:n]
+    assert_equal :activerecord, third_span[:n]
+    assert_equal :activerecord, fourth_span[:n]
 
     assert_equal "INSERT INTO \"blocks\" (\"name\", \"color\", \"created_at\", \"updated_at\") VALUES ($?, $?, $?, $?) RETURNING \"id\"", second_span[:data][:activerecord][:sql]
     assert_equal "SELECT  \"blocks\".* FROM \"blocks\" WHERE \"blocks\".\"name\" = $? ORDER BY \"blocks\".\"id\" ASC LIMIT $?", third_span[:data][:activerecord][:sql]
@@ -55,21 +55,18 @@ class ActiveRecordTest < Minitest::Test
 
     Net::HTTP.get(URI.parse('http://localhost:3205/test/db'))
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    trace = traces.first
+    spans = ::Instana.processor.queued_spans
+    assert_equal 6, spans.length
 
-    assert_equal 6, trace.spans.length
-    spans = trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[2]
-    third_span = spans[3]
-    fourth_span = spans[4]
+    first_span = spans[5]
+    second_span = spans[0]
+    third_span = spans[1]
+    fourth_span = spans[2]
 
-    assert_equal :rack, first_span.name
-    assert_equal :activerecord, second_span.name
-    assert_equal :activerecord, third_span.name
-    assert_equal :activerecord, fourth_span.name
+    assert_equal :rack, first_span[:n]
+    assert_equal :activerecord, second_span[:n]
+    assert_equal :activerecord, third_span[:n]
+    assert_equal :activerecord, fourth_span[:n]
 
     assert_equal "INSERT INTO `blocks` (`name`, `color`, `created_at`, `updated_at`) VALUES (?, ?, ?, ?)", second_span[:data][:activerecord][:sql]
     assert_equal "SELECT  `blocks`.* FROM `blocks` WHERE `blocks`.`name` = ? ORDER BY `blocks`.`id` ASC LIMIT ?", third_span[:data][:activerecord][:sql]

data/test/instrumentation/dalli_test.rb

@@ -24,18 +24,15 @@ class DalliTest < Minitest::Test
 
     assert_equal :boom, result
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    trace = traces.first
-
-    # Excon validation
-    assert_equal 2, trace.spans.length
-    spans = trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
-
-    assert_equal :dalli_test, first_span.name
-    assert_equal :memcache, second_span.name
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
+
+    first_span = spans[1]
+    second_span = spans[0]
+
+    validate_sdk_span(first_span, {:name => :dalli_test, :type => :intermediate})
+
+    assert_equal :memcache, second_span[:n]
     assert_equal false, second_span.key?(:error)
     assert second_span[:p] == first_span[:s]
     assert first_span[:t] == first_span[:s]
@@ -60,18 +57,15 @@ class DalliTest < Minitest::Test
 
     assert result.is_a?(Integer)
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    trace = traces.first
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
 
-    # Excon validation
-    assert_equal 2, trace.spans.length
-    spans = trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
+    first_span = spans[1]
+    second_span = spans[0]
 
-    assert_equal :dalli_test, first_span.name
-    assert_equal :memcache, second_span.name
+    validate_sdk_span(first_span, {:name => :dalli_test, :type => :intermediate})
+
+    assert_equal :memcache, second_span[:n]
     assert_equal false, second_span.key?(:error)
     assert second_span[:p] == first_span[:s]
     assert first_span[:t] == first_span[:s]
@@ -97,18 +91,15 @@ class DalliTest < Minitest::Test
 
     assert result.is_a?(Integer)
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    trace = traces.first
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
+
+    first_span = spans[1]
+    second_span = spans[0]
 
-    # Excon validation
-    assert_equal 2, trace.spans.length
-    spans = trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
+    validate_sdk_span(first_span, {:name => :dalli_test, :type => :intermediate})
 
-    assert_equal :dalli_test, first_span.name
-    assert_equal :memcache, second_span.name
+    assert_equal :memcache, second_span[:n]
     assert_equal false, second_span.key?(:error)
     assert second_span[:p] == first_span[:s]
     assert first_span[:t] == first_span[:s]
@@ -134,18 +125,15 @@ class DalliTest < Minitest::Test
 
     assert_equal true, result
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    trace = traces.first
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
 
-    # Excon validation
-    assert_equal 2, trace.spans.length
-    spans = trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
+    first_span = spans[1]
+    second_span = spans[0]
 
-    assert_equal :dalli_test, first_span.name
-    assert_equal :memcache, second_span.name
+    validate_sdk_span(first_span, {:name => :dalli_test, :type => :intermediate})
+
+    assert_equal :memcache, second_span[:n]
     assert_equal false, second_span.key?(:error)
     assert second_span[:p] == first_span[:s]
     assert first_span[:t] == first_span[:s]
@@ -171,18 +159,15 @@ class DalliTest < Minitest::Test
 
     assert_equal 1, result
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    trace = traces.first
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
+
+    first_span = spans[1]
+    second_span = spans[0]
 
-    # Excon validation
-    assert_equal 2, trace.spans.length
-    spans = trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
+    validate_sdk_span(first_span, {:name => :dalli_test, :type => :intermediate})
 
-    assert_equal :dalli_test, first_span.name
-    assert_equal :memcache, second_span.name
+    assert_equal :memcache, second_span[:n]
     assert_equal false, second_span.key?(:error)
     assert second_span[:p] == first_span[:s]
     assert first_span[:t] == first_span[:s]
@@ -208,18 +193,15 @@ class DalliTest < Minitest::Test
 
     assert_equal 0, result
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    trace = traces.first
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
 
-    # Excon validation
-    assert_equal 2, trace.spans.length
-    spans = trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
+    first_span = spans[1]
+    second_span = spans[0]
 
-    assert_equal :dalli_test, first_span.name
-    assert_equal :memcache, second_span.name
+    validate_sdk_span(first_span, {:name => :dalli_test, :type => :intermediate})
+
+    assert_equal :memcache, second_span[:n]
     assert_equal false, second_span.key?(:error)
     assert second_span[:p] == first_span[:s]
     assert first_span[:t] == first_span[:s]
@@ -244,18 +226,15 @@ class DalliTest < Minitest::Test
       @dc.get_multi(:one, :two, :three, :four)
     end
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    trace = traces.first
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
+
+    first_span = spans[1]
+    second_span = spans[0]
 
-    # Excon validation
-    assert_equal 2, trace.spans.length
-    spans = trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
+    validate_sdk_span(first_span, {:name => :dalli_test, :type => :intermediate})
 
-    assert_equal :dalli_test, first_span.name
-    assert_equal :memcache, second_span.name
+    assert_equal :memcache, second_span[:n]
     assert_equal false, second_span.key?(:error)
     assert second_span[:p] == first_span[:s]
     assert first_span[:t] == first_span[:s]

data/test/instrumentation/excon_test.rb

@@ -22,41 +22,29 @@ class ExconTest < Minitest::Test
       connection.get(:path => '/?basic_get')
     end
 
-    traces = Instana.processor.queued_traces
-    assert_equal 2, traces.length
-    rs_trace = traces[0]
-    http_trace = traces[1]
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
 
-    # Excon validation
-    assert_equal 2, http_trace.spans.length
-    spans = http_trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
+    sdk_span = find_first_span_by_name(spans, :'excon-test')
+    excon_span = find_first_span_by_name(spans, :excon)
+    rack_span = find_first_span_by_name(spans, :rack)
 
-    # Span name validation
-    assert_equal :sdk, first_span[:n]
-    assert_equal :"excon-test", first_span[:data][:sdk][:name]
-    assert_equal :excon, second_span[:n]
-
-    # first_span is the parent of second_span
-    assert_equal first_span.id, second_span[:p]
+    validate_sdk_span(sdk_span, {:name => :'excon-test', :type => :intermediate})
 
     # data keys/values
-    refute_nil second_span.key?(:data)
-    refute_nil second_span[:data].key?(:http)
-    assert_equal "http://127.0.0.1:6511/", second_span[:data][:http][:url]
-    assert_equal 200, second_span[:data][:http][:status]
+    refute_nil excon_span.key?(:data)
+    refute_nil excon_span[:data].key?(:http)
+    assert_equal "http://127.0.0.1:6511/", excon_span[:data][:http][:url]
+    assert_equal 200, excon_span[:data][:http][:status]
 
     # excon backtrace not included by default check
-    assert !second_span.key?(:stack)
+    assert !excon_span.key?(:stack)
 
-    # Rack server trace validation
-    assert_equal 1, rs_trace.spans.length
-    rs_span = rs_trace.spans.to_a[0]
+    assert_equal sdk_span[:t], excon_span[:t]
+    assert_equal rack_span[:t], excon_span[:t]
 
-    # Rack server trace should have the same trace ID
-    assert_equal http_trace.id, rs_span[:t].to_i
-    assert_equal rs_span[:p].to_i, second_span[:s]
+    assert_equal rack_span[:p], excon_span[:s]
+    assert_equal excon_span[:p], sdk_span[:s]
   end
 
   def test_basic_get_with_error
@@ -67,46 +55,37 @@ class ExconTest < Minitest::Test
     Excon.defaults[:middlewares].delete ::WebMock::HttpLibAdapters::ExconAdapter
     Excon.defaults[:middlewares].delete ::Excon::Middleware::Mock
 
-    url = "http://127.0.0.1:6500"
+    url = "http://127.0.0.1:6511"
 
     begin
       connection = Excon.new(url)
       Instana.tracer.start_or_continue_trace('excon-test') do
-        connection.get(:path => '/?basic_get')
+        connection.get(:path => '/error')
       end
     rescue
     end
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    http_trace = traces.first
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
 
-    # Excon validation
-    assert_equal 2, http_trace.spans.length
-    spans = http_trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
+    rack_span = find_first_span_by_name(spans, :rack)
+    excon_span = find_first_span_by_name(spans, :excon)
+    sdk_span = find_first_span_by_name(spans, :'excon-test')
 
-    # Span name validation
-    assert_equal :sdk, first_span[:n]
-    assert_equal :"excon-test", first_span[:data][:sdk][:name]
-    assert_equal :excon, second_span[:n]
+    validate_sdk_span(sdk_span, {:name => :'excon-test', :type => :intermediate})
 
-    # first_span is the parent of second_span
-    assert_equal first_span.id, second_span[:p]
-
-    # data keys/values
-    refute_nil second_span.key?(:data)
-    refute_nil second_span[:data].key?(:http)
-    assert_equal "http://127.0.0.1:6500/", second_span[:data][:http][:url]
-    assert_equal nil, second_span[:data][:http][:status]
+    assert_equal sdk_span[:s], excon_span[:p]
+    assert_equal excon_span[:s], rack_span[:p]
 
-    # excon span should include an error backtrace
-    assert second_span.key?(:stack)
+    assert_equal :excon, excon_span[:n]
+    refute_nil excon_span.key?(:data)
+    refute_nil excon_span[:data].key?(:http)
+    assert_equal "http://127.0.0.1:6511/error", excon_span[:data][:http][:url]
+    assert_equal 500, excon_span[:data][:http][:status]
 
     # error validation
-    assert_equal true, second_span[:error]
-    #assert_equal 1, second_span[:ec]
+    assert_equal true, excon_span[:error]
+    assert_equal 1, excon_span[:ec]
   end
 
   def test_pipelined_requests
@@ -125,47 +104,44 @@ class ExconTest < Minitest::Test
       connection.requests([request, request, request])
     end
 
-    traces = Instana.processor.queued_traces
-    assert_equal 4, traces.length
-    http_trace = traces[3]
-
-    # Excon validation
-    assert_equal 4, http_trace.spans.length
-    spans = http_trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
-    third_span = spans[2]
-    fourth_span = spans[3]
-
-    # Span name validation
-    assert_equal :sdk, first_span[:n]
-    assert_equal :"excon-test", first_span[:data][:sdk][:name]
-    assert_equal :excon, second_span[:n]
-    assert_equal :excon, third_span[:n]
-    assert_equal :excon, fourth_span[:n]
-
-    # first_span is the parent of second/third/fourth_span
-    assert_equal first_span.id, second_span[:p]
-    assert_equal first_span.id, third_span[:p]
-    assert_equal first_span.id, fourth_span[:p]
+    spans = ::Instana.processor.queued_spans
+    assert_equal 7, spans.length
 
-    # data keys/values
-    refute_nil second_span.key?(:data)
-    refute_nil second_span[:data].key?(:http)
-    assert_equal "http://127.0.0.1:6511/", second_span[:data][:http][:url]
-    assert_equal 200, second_span[:data][:http][:status]
-    assert !second_span.key?(:stack)
-
-    refute_nil third_span.key?(:data)
-    refute_nil third_span[:data].key?(:http)
-    assert_equal "http://127.0.0.1:6511/", third_span[:data][:http][:url]
-    assert_equal 200, third_span[:data][:http][:status]
-    assert !third_span.key?(:stack)
-
-    refute_nil fourth_span.key?(:data)
-    refute_nil fourth_span[:data].key?(:http)
-    assert_equal "http://127.0.0.1:6511/", fourth_span[:data][:http][:url]
-    assert_equal 200, fourth_span[:data][:http][:status]
-    assert !fourth_span.key?(:stack)
+    rack_spans = find_spans_by_name(spans, :rack)
+    excon_spans = find_spans_by_name(spans, :excon)
+    sdk_span = find_first_span_by_name(spans, :'excon-test')
+
+    validate_sdk_span(sdk_span, {:name => :'excon-test', :type => :intermediate})
+
+    assert_equal 3, rack_spans.length
+    assert_equal 3, excon_spans.length
+
+    # ::Instana::Util.pry!
+
+    for rack_span in rack_spans
+      # data keys/values
+      refute_nil rack_span.key?(:data)
+      refute_nil rack_span[:data].key?(:http)
+      assert_equal "/", rack_span[:data][:http][:url]
+      assert_equal 200, rack_span[:data][:http][:status]
+      assert !rack_span.key?(:stack)
+
+      # Make sure a parent is specified and that we have it
+      refute_nil rack_span[:p]
+      excon_span = find_span_by_id(spans, rack_span[:p])
+      assert_equal :excon, excon_span[:n]
+
+      refute_nil excon_span.key?(:data)
+      refute_nil excon_span[:data].key?(:http)
+      assert_equal "http://127.0.0.1:6511/", excon_span[:data][:http][:url]
+      assert_equal 200, excon_span[:data][:http][:status]
+      assert !excon_span.key?(:stack)
+
+      # walk up the line
+      refute_nil excon_span[:p]
+      grandparent_span = find_span_by_id(spans, excon_span[:p])
+      assert_nil grandparent_span[:p]
+      assert_equal :sdk, grandparent_span[:n]
+    end
   end
 end

data/test/instrumentation/grpc_test.rb

@@ -5,39 +5,8 @@ class GrpcTest < Minitest::Test
     PingPongService::Stub.new('127.0.0.1:50051', :this_channel_is_insecure)
   end
 
-  # The order of traces are non-deterministic, could not predict
-  # which trace is server or client. This method is to choose the
-  # right trace based on span's name
-  def differentiate_trace(traces)
-    trying_client = traces[0]
-    trying_server = traces[1]
-
-    try_successfully = trying_client.spans.any? do |span|
-      span.name == :'rpc-client'
-    end
-
-    if try_successfully
-      [trying_client, trying_server]
-    else
-      [trying_server, trying_client]
-    end
-  end
-
-  def assert_client_trace(client_trace, call: '', call_type: '', error: nil)
-    assert_equal 2, client_trace.spans.length
-    spans = client_trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
-
-    # Span name validation
-    assert_equal :sdk, first_span[:n]
-    assert_equal :rpctests, first_span[:data][:sdk][:name]
-    assert_equal :'rpc-client', second_span[:n]
-
-    # first_span is the parent of second_span
-    assert_equal first_span.id, second_span[:p]
-
-    data = second_span[:data]
+  def assert_client_span(client_span, call: '', call_type: '', error: nil)
+    data = client_span[:data]
     assert_equal '127.0.0.1:50051', data[:rpc][:host]
     assert_equal :grpc, data[:rpc][:flavor]
     assert_equal call, data[:rpc][:call]
@@ -49,14 +18,11 @@ class GrpcTest < Minitest::Test
     end
   end
 
-  def assert_server_trace(server_trace, call: '', call_type: '', error: nil)
-    assert_equal 1, server_trace.spans.length
-    span = server_trace.spans.to_a.first
-
+  def assert_server_span(server_span, call: '', call_type: '', error: nil)
     # Span name validation
-    assert_equal :'rpc-server', span[:n]
+    assert_equal :'rpc-server', server_span[:n]
 
-    data = span[:data]
+    data = server_span[:data]
     assert_equal :grpc, data[:rpc][:flavor]
     assert_equal call, data[:rpc][:call]
     assert_equal call_type, data[:rpc][:call_type]
@@ -83,22 +49,31 @@ class GrpcTest < Minitest::Test
     # Pause for a split second to allow traces to be queued
     sleep 0.2
 
-    assert_equal 2, ::Instana.processor.queue_count
-    client_trace, server_trace = differentiate_trace(
-      Instana.processor.queued_traces
-    )
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
+
+    validate_sdk_span(sdk_span)
 
-    assert_client_trace(
-      client_trace,
-      call: '/PingPongService/Ping',
-      call_type: :request_response
+    assert_client_span(
+        client_span,
+        call: '/PingPongService/Ping',
+        call_type: :request_response
     )
 
-    assert_server_trace(
-      server_trace,
-      call: '/PingPongService/Ping',
-      call_type: :request_response
+    assert_server_span(
+        server_span,
+        call: '/PingPongService/Ping',
+        call_type: :request_response
     )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
   end
 
   def test_client_streamer
@@ -119,22 +94,31 @@ class GrpcTest < Minitest::Test
     # Pause for a split second to allow traces to be queued
     sleep 0.2
 
-    assert_equal 2, ::Instana.processor.queue_count
-    client_trace, server_trace = differentiate_trace(
-      Instana.processor.queued_traces
-    )
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
 
-    assert_client_trace(
-      client_trace,
-      call: '/PingPongService/PingWithClientStream',
-      call_type: :client_streamer
+    validate_sdk_span(sdk_span)
+
+    assert_client_span(
+        client_span,
+        call: '/PingPongService/PingWithClientStream',
+        call_type: :client_streamer
     )
 
-    assert_server_trace(
-      server_trace,
-      call: '/PingPongService/PingWithClientStream',
-      call_type: :client_streamer
+    assert_server_span(
+        server_span,
+        call: '/PingPongService/PingWithClientStream',
+        call_type: :client_streamer
     )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
   end
 
   def test_server_streamer
@@ -151,22 +135,31 @@ class GrpcTest < Minitest::Test
     # Pause for a split second to allow traces to be queued
     sleep 0.2
 
-    assert_equal 2, ::Instana.processor.queue_count
-    client_trace, server_trace = differentiate_trace(
-      Instana.processor.queued_traces
-    )
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
 
-    assert_client_trace(
-      client_trace,
-      call: '/PingPongService/PingWithServerStream',
-      call_type: :server_streamer
+    validate_sdk_span(sdk_span)
+
+    assert_client_span(
+        client_span,
+        call: '/PingPongService/PingWithServerStream',
+        call_type: :server_streamer
     )
 
-    assert_server_trace(
-      server_trace,
-      call: '/PingPongService/PingWithServerStream',
-      call_type: :server_streamer
+    assert_server_span(
+        server_span,
+        call: '/PingPongService/PingWithServerStream',
+        call_type: :server_streamer
     )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
   end
 
   def test_bidi_streamer
@@ -187,22 +180,31 @@ class GrpcTest < Minitest::Test
     # Pause for a split second to allow traces to be queued
     sleep 0.2
 
-    assert_equal 2, ::Instana.processor.queue_count
-    client_trace, server_trace = differentiate_trace(
-      Instana.processor.queued_traces
-    )
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
 
-    assert_client_trace(
-      client_trace,
-      call: '/PingPongService/PingWithBidiStream',
-      call_type: :bidi_streamer
+    validate_sdk_span(sdk_span)
+
+    assert_client_span(
+        client_span,
+        call: '/PingPongService/PingWithBidiStream',
+        call_type: :bidi_streamer
     )
 
-    assert_server_trace(
-      server_trace,
-      call: '/PingPongService/PingWithBidiStream',
-      call_type: :bidi_streamer
+    assert_server_span(
+        server_span,
+        call: '/PingPongService/PingWithBidiStream',
+        call_type: :bidi_streamer
     )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
   end
 
   def test_request_response_failure
@@ -217,23 +219,32 @@ class GrpcTest < Minitest::Test
     # Pause for a split second to allow traces to be queued
     sleep 0.2
 
-    assert_equal 2, ::Instana.processor.queue_count
-    client_trace, server_trace = differentiate_trace(
-      Instana.processor.queued_traces
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
+
+    validate_sdk_span(sdk_span)
+    
+    assert_client_span(
+        client_span,
+        call: '/PingPongService/FailToPing',
+        call_type: :request_response,
+        error: 'Unexpected failed'
     )
-
-    assert_client_trace(
-      client_trace,
-      call: '/PingPongService/FailToPing',
-      call_type: :request_response,
-      error: 'Unexpected failed'
-    )
-    assert_server_trace(
-      server_trace,
-      call: '/PingPongService/FailToPing',
-      call_type: :request_response,
-      error: 'Unexpected failed'
+    assert_server_span(
+        server_span,
+        call: '/PingPongService/FailToPing',
+        call_type: :request_response,
+        error: 'Unexpected failed'
     )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
   end
 
   def test_client_streamer_failure
@@ -252,24 +263,33 @@ class GrpcTest < Minitest::Test
     # Pause for a split second to allow traces to be queued
     sleep 0.2
 
-    assert_equal 2, ::Instana.processor.queue_count
-    client_trace, server_trace = differentiate_trace(
-      Instana.processor.queued_traces
-    )
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
+
+    validate_sdk_span(sdk_span)
 
-    assert_client_trace(
-      client_trace,
+    assert_client_span(
+      client_span,
       call: '/PingPongService/FailToPingWithClientStream',
       call_type: :client_streamer,
       error: 'Unexpected failed'
     )
 
-    assert_server_trace(
-      server_trace,
+    assert_server_span(
+      server_span,
       call: '/PingPongService/FailToPingWithClientStream',
       call_type: :client_streamer,
       error: 'Unexpected failed'
     )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
   end
 
   def test_server_streamer_failure
@@ -286,23 +306,32 @@ class GrpcTest < Minitest::Test
     # Pause for a split second to allow traces to be queued
     sleep 0.2
 
-    assert_equal 2, ::Instana.processor.queue_count
-    client_trace, server_trace = differentiate_trace(
-      Instana.processor.queued_traces
-    )
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
+
+    validate_sdk_span(sdk_span)
 
-    assert_client_trace(
-      client_trace,
+    assert_client_span(
+      client_span,
       call: '/PingPongService/FailToPingWithServerStream',
       call_type: :server_streamer
     )
 
-    assert_server_trace(
-      server_trace,
+    assert_server_span(
+      server_span,
       call: '/PingPongService/FailToPingWithServerStream',
       call_type: :server_streamer,
       error: 'Unexpected failed'
     )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
   end
 
   def test_bidi_streamer_failure
@@ -318,22 +347,31 @@ class GrpcTest < Minitest::Test
     # Pause for a split second to allow traces to be queued
     sleep 0.2
 
-    assert_equal 2, ::Instana.processor.queue_count
-    client_trace, server_trace = differentiate_trace(
-      Instana.processor.queued_traces
-    )
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
 
-    assert_client_trace(
-      client_trace,
+    validate_sdk_span(sdk_span)
+
+    assert_client_span(
+      client_span,
       call: '/PingPongService/FailToPingWithBidiStream',
       call_type: :bidi_streamer
     )
 
-    assert_server_trace(
-      server_trace,
+    assert_server_span(
+      server_span,
       call: '/PingPongService/FailToPingWithBidiStream',
       call_type: :bidi_streamer,
       error: 'Unexpected failed'
     )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
   end
 end