instana 1.9.7 → 1.10.0.slimfast

data/test/instrumentation/net-http_test.rb

@@ -22,24 +22,19 @@ class NetHTTPTest < Minitest::Test
       end
     end
 
-    assert_equal 2, ::Instana.processor.queue_count
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
 
-    traces = Instana.processor.queued_traces
-    rs_trace = traces[0]
-    http_trace = traces[1]
-
-    # Net::HTTP trace validation
-    assert_equal 2, http_trace.spans.length
-    spans = http_trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
+    rs_span = find_first_span_by_name(spans, :rack)
+    first_span = find_first_span_by_name(spans, :'net-http-test')
+    second_span = find_first_span_by_name(spans, :'net-http')
 
     # Span name validation
     assert_equal :sdk, first_span[:n]
     assert_equal :'net-http', second_span[:n]
 
     # first_span is the parent of second_span
-    assert_equal first_span.id, second_span[:p]
+    assert_equal first_span[:s], second_span[:p]
 
     # data keys/values
     refute_nil second_span.key?(:data)
@@ -48,14 +43,12 @@ class NetHTTPTest < Minitest::Test
     assert_equal "200", second_span[:data][:http][:status]
     assert !second_span.key?(:stack)
 
-    # Rack server trace validation
-    assert_equal 1, rs_trace.spans.length
-    rs_span = rs_trace.spans.to_a[0]
-
     # Rack server trace should have the same trace ID
-    assert_equal http_trace.id, rs_span[:t].to_i
+    assert_equal rs_span[:t], first_span[:t]
+    assert_equal first_span[:t], second_span[:t]
+
     # Rack server trace should have net-http has parent span
-    assert_equal second_span.id, rs_span[:p].to_i
+    assert_equal second_span[:s], rs_span[:p]
 
     WebMock.disable_net_connect!
   end
@@ -70,40 +63,33 @@ class NetHTTPTest < Minitest::Test
       response = http.request(Net::HTTP::Post.new("/"))
     end
 
-    assert_equal 2, ::Instana.processor.queue_count
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
 
-    traces = Instana.processor.queued_traces
-    rs_trace = traces[0]
-    http_trace = traces[1]
-
-    # Net::HTTP trace 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)
+    sdk_span = find_first_span_by_name(spans, :'net-http-test')
+    http_span = find_first_span_by_name(spans, :'net-http')
 
     # Span name validation
-    assert_equal :sdk, first_span[:n]
-    assert_equal :'net-http', second_span[:n]
+    assert_equal :sdk, sdk_span[:n]
+    assert_equal :'net-http', http_span[:n]
 
     # first_span is the parent of second_span
-    assert_equal first_span.id, second_span[:p]
+    assert_equal sdk_span[:s], http_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:6511/", second_span[:data][:http][:url]
-    assert_equal "200", second_span[:data][:http][:status]
-    assert !second_span.key?(:stack)
-
-    # Rack server trace validation
-    assert_equal 1, rs_trace.spans.length
-    rs_span = rs_trace.spans.to_a[0]
+    refute_nil http_span.key?(:data)
+    refute_nil http_span[:data].key?(:http)
+    assert_equal "http://127.0.0.1:6511/", http_span[:data][:http][:url]
+    assert_equal "200", http_span[:data][:http][:status]
+    assert !http_span.key?(:stack)
 
     # Rack server trace should have the same trace ID
-    assert_equal http_trace.id, rs_span[:t].to_i
+    assert_equal rack_span[:t], sdk_span[:t]
+    assert_equal sdk_span[:t], http_span[:t]
+
     # Rack server trace should have net-http has parent span
-    assert_equal second_span.id, rs_span[:p].to_i
+    assert_equal http_span[:s], rack_span[:p]
 
     WebMock.disable_net_connect!
   end
@@ -121,16 +107,15 @@ class NetHTTPTest < Minitest::Test
       nil
     end
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
-    t = traces[0]
-    assert_equal 1, t.spans.count
-    assert t.has_error?
-    spans = t.spans.to_a
-    first_span = spans[0]
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.length
+
+    first_span = spans.first
 
-    assert_equal :'net-http-error-test', first_span.name
-    assert first_span.custom?
+    assert_equal :sdk, first_span[:n]
+    assert_equal :'net-http-error-test', first_span[:data][:sdk][:name]
+    assert_equal true, first_span[:error]
+    assert_equal 1, first_span[:ec]
     ts_key = first_span[:data][:sdk][:custom][:logs].keys.first
     assert first_span[:data][:sdk][:custom][:logs].key?(ts_key)
     assert first_span[:data][:sdk][:custom][:logs][ts_key].key?(:event)
@@ -149,20 +134,26 @@ class NetHTTPTest < Minitest::Test
       response = http.request(Net::HTTP::Get.new("/error"))
     end
 
-    traces = Instana.processor.queued_traces
-    assert_equal 2, traces.length
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
+
+    rack_span = find_first_span_by_name(spans, :rack)
+    sdk_span = find_first_span_by_name(spans, :'net-http-error-test')
+    http_span = find_first_span_by_name(spans, :'net-http')
 
-    request_trace = traces[1]
-    assert_equal 2, request_trace.spans.length
-    assert request_trace.has_error?
-    http_span = request_trace.spans.to_a[1]
+    assert_equal :sdk, sdk_span[:n]
+    assert_equal :'net-http-error-test', sdk_span[:data][:sdk][:name]
+    assert_equal nil, sdk_span[:error]
+    assert_equal nil, sdk_span[:ec]
 
     refute_nil http_span.key?(:data)
     refute_nil http_span[:data].key?(:http)
     assert_equal "http://127.0.0.1:6511/error", http_span[:data][:http][:url]
     assert_equal "500", http_span[:data][:http][:status]
-    assert_equal :'net-http', http_span.name
+    assert_equal :'net-http', http_span[:n]
     assert !http_span.key?(:stack)
+    assert_equal true, http_span[:error]
+    assert_equal 1, http_span[:ec]
 
     WebMock.disable_net_connect!
   end

data/test/instrumentation/redis_test.rb

@@ -94,14 +94,12 @@ class RedisTest < Minitest::Test
   end
 
   def assert_redis_trace(command, with_error: nil)
-    assert_equal 1, ::Instana.processor.queue_count
-    trace = ::Instana.processor.queued_traces.first
-
-    assert_equal 2, trace.spans.length
-    first_span, second_span = trace.spans.to_a
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
+    first_span, second_span = spans.to_a.reverse
 
     # first_span is the parent of second_span
-    assert_equal first_span.id, second_span[:p]
+    assert_equal first_span[:s], second_span[:p]
     assert_equal :sdk, first_span[:n]
     assert_equal :redis, second_span[:n]
 

data/test/instrumentation/resque_test.rb

@@ -5,6 +5,8 @@ require 'resque'
 
 if ENV.key?('REDIS_URL')
   ::Resque.redis = ENV['REDIS_URL']
+elsif ENV.key?('I_REDIS_URL')
+  ::Resque.redis = ENV['I_REDIS_URL']
 else
   ::Resque.redis = 'localhost:6379'
 end
@@ -25,20 +27,21 @@ class ResqueClientTest < Minitest::Test
       ::Resque.enqueue(FastJob)
     end
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
 
-    spans = traces[0].spans.to_a
-    assert_equal 3, spans.count
+    sdk_span = find_first_span_by_name(spans, :'resque-client_test')
+    resque_span = find_first_span_by_name(spans, :'resque-client')
+    redis_span = find_first_span_by_name(spans, :redis)
 
-    assert_equal :'resque-client_test', spans[0][:data][:sdk][:name]
+    assert_equal :'resque-client_test', sdk_span[:data][:sdk][:name]
 
-    assert_equal :"resque-client", spans[1][:n]
-    assert_equal "FastJob", spans[1][:data][:'resque-client'][:job]
-    assert_equal :critical, spans[1][:data][:'resque-client'][:queue]
-    assert_equal false, spans[1][:data][:'resque-client'].key?(:error)
+    assert_equal :"resque-client", resque_span[:n]
+    assert_equal "FastJob", resque_span[:data][:'resque-client'][:job]
+    assert_equal :critical, resque_span[:data][:'resque-client'][:queue]
+    assert_equal false, resque_span[:data][:'resque-client'].key?(:error)
 
-    assert_equal :redis, spans[2][:n]
+    assert_equal :redis, redis_span[:n]
   end
 
   def test_enqueue_to
@@ -46,18 +49,19 @@ class ResqueClientTest < Minitest::Test
       ::Resque.enqueue_to(:critical, FastJob)
     end
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
 
-    spans = traces[0].spans.to_a
-    assert_equal 3, spans.count
+    sdk_span = find_first_span_by_name(spans, :'resque-client_test')
+    resque_span = find_first_span_by_name(spans, :'resque-client')
+    redis_span = find_first_span_by_name(spans, :redis)
 
-    assert_equal :'resque-client_test', spans[0][:data][:sdk][:name]
-    assert_equal :"resque-client", spans[1][:n]
-    assert_equal "FastJob", spans[1][:data][:'resque-client'][:job]
-    assert_equal :critical, spans[1][:data][:'resque-client'][:queue]
-    assert_equal false, spans[1][:data][:'resque-client'].key?(:error)
-    assert_equal :redis, spans[2][:n]
+    assert_equal :'resque-client_test', sdk_span[:data][:sdk][:name]
+    assert_equal :"resque-client", resque_span[:n]
+    assert_equal "FastJob", resque_span[:data][:'resque-client'][:job]
+    assert_equal :critical, resque_span[:data][:'resque-client'][:queue]
+    assert_equal false, resque_span[:data][:'resque-client'].key?(:error)
+    assert_equal :redis, redis_span[:n]
   end
 
   def test_dequeue
@@ -65,33 +69,31 @@ class ResqueClientTest < Minitest::Test
       ::Resque.dequeue(FastJob, { :generate => :farfalla })
     end
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
 
-    spans = traces[0].spans.to_a
-    assert_equal 3, spans.count
+    sdk_span = find_first_span_by_name(spans, :'resque-client_test')
+    resque_span = find_first_span_by_name(spans, :'resque-client')
+    redis_span = find_first_span_by_name(spans, :redis)
 
-    assert_equal :'resque-client_test', spans[0][:data][:sdk][:name]
+    assert_equal :'resque-client_test', sdk_span[:data][:sdk][:name]
     assert_equal :"resque-client", spans[1][:n]
-    assert_equal "FastJob", spans[1][:data][:'resque-client'][:job]
-    assert_equal :critical, spans[1][:data][:'resque-client'][:queue]
-    assert_equal false, spans[1][:data][:'resque-client'].key?(:error)
-    assert_equal :redis, spans[2][:n]
+    assert_equal "FastJob", resque_span[:data][:'resque-client'][:job]
+    assert_equal :critical, resque_span[:data][:'resque-client'][:queue]
+    assert_equal false, resque_span[:data][:'resque-client'].key?(:error)
+    assert_equal :redis, redis_span[:n]
   end
 
   def test_worker_job
     Resque::Job.create(:critical, FastJob)
     @worker.work(0)
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
-
-    spans = traces[0].spans.to_a
-    assert_equal 3, spans.count
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
 
-    resque_span = spans[0]
+    resque_span = spans[2]
     redis1_span = spans[1]
-    redis2_span = spans[2]
+    redis2_span = spans[0]
 
     assert_equal :'resque-worker', resque_span[:n]
     assert_equal false, resque_span.key?(:error)
@@ -110,12 +112,10 @@ class ResqueClientTest < Minitest::Test
     Resque::Job.create(:critical, ErrorJob)
     @worker.work(0)
 
-    traces = Instana.processor.queued_traces
-    assert_equal 1, traces.length
+    spans = ::Instana.processor.queued_spans
+    assert_equal 5, spans.length
 
-    spans = traces[0].spans.to_a
-    resque_span = spans[0]
-    assert_equal 5, spans.count
+    resque_span = find_first_span_by_name(spans, :'resque-worker')
 
     assert_equal :'resque-worker', resque_span[:n]
     assert_equal true, resque_span.key?(:error)

data/test/instrumentation/rest-client_test.rb

@@ -17,44 +17,38 @@ class RestClientTest < Minitest::Test
       RestClient.get url
     end
 
-    assert_equal 2, ::Instana.processor.queue_count
+    spans = ::Instana.processor.queued_spans
+    assert_equal 4, spans.length
 
-    traces = Instana.processor.queued_traces
-    rs_trace = traces[0]
-    http_trace = traces[1]
+    rack_span = find_first_span_by_name(spans, :rack)
+    sdk_span = find_first_span_by_name(spans, :'restclient-test')
+    rest_span = find_first_span_by_name(spans, :'rest-client')
+    net_span = find_first_span_by_name(spans, :'net-http')
 
-    # RestClient trace validation
-    assert_equal 3, http_trace.spans.length
-    spans = http_trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
-    third_span = spans[2]
+    validate_sdk_span(sdk_span, {:name => :'restclient-test', :type => :intermediate})
+    validate_sdk_span(rest_span, {:name => :'rest-client', :type => :intermediate})
 
     # Span name validation
-    assert first_span.custom?
-    assert_equal :"restclient-test", first_span.name
-    assert_equal :"rest-client", second_span.name
-    assert_equal :"net-http", third_span.name
+    assert_equal :rack, rack_span[:n]
+    assert_equal :sdk, sdk_span[:n]
+    assert_equal :sdk, rest_span[:n]
+    assert_equal :"net-http", net_span[:n]
 
-    # first_span is the parent of second_span
-    assert_equal first_span.id, second_span[:p]
-    # second_span is parent of third_span
-    assert_equal second_span.id, third_span[:p]
+    # Trace IDs and relationships
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, rest_span[:t]
+    assert_equal trace_id, net_span[:t]
+    assert_equal trace_id, rack_span[:t]
+
+    assert_equal sdk_span[:s], rest_span[:p]
+    assert_equal rest_span[:s], net_span[:p]
+    assert_equal net_span[:s], rack_span[:p]
 
     # data keys/values
-    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]
-
-    # Rack server trace validation
-    assert_equal 1, rs_trace.spans.length
-    rs_span = rs_trace.spans.to_a[0]
-
-    # Rack server trace should have the same trace ID
-    assert_equal http_trace.id, rs_span[:t].to_i
-    # Rack server trace should have net-http has parent span
-    assert_equal third_span.id, rs_span[:p].to_i
+    refute_nil net_span.key?(:data)
+    refute_nil net_span[:data].key?(:http)
+    assert_equal "http://127.0.0.1:6511/", net_span[:data][:http][:url]
+    assert_equal "200", net_span[:data][:http][:status]
 
     WebMock.disable_net_connect!
   end

data/test/instrumentation/sidekiq-client_test.rb

@@ -65,18 +65,14 @@ class SidekiqClientTest < Minitest::Test
   end
 
   def assert_normal_trace_recorded(job)
-    assert_equal 1, ::Instana.processor.queue_count
-    client_trace = Instana.processor.queued_traces.first
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
 
-    assert_equal 2, client_trace.spans.length
-    spans = client_trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
+    first_span = spans[1]
+    second_span = spans[0]
 
-    assert_equal :sdk, first_span[:n]
-    assert_equal :sidekiqtests, first_span[:data][:sdk][:name]
-
-    assert_equal first_span.id, second_span[:p]
+    assert_equal first_span[:s], second_span[:p]
+    validate_sdk_span(first_span, {:name => :sidekiqtests, :type => :intermediate})
 
     assert_equal :'sidekiq-client', second_span[:n]
     assert_equal 'some_random_queue', second_span[:data][:'sidekiq-client'][:queue]
@@ -86,18 +82,14 @@ class SidekiqClientTest < Minitest::Test
   end
 
   def assert_failure_trace_recorded
-    assert_equal 1, ::Instana.processor.queue_count
-    client_trace = Instana.processor.queued_traces.first
-
-    assert_equal 2, client_trace.spans.length
-    spans = client_trace.spans.to_a
-    first_span = spans[0]
-    second_span = spans[1]
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
 
-    assert_equal :sdk, first_span[:n]
-    assert_equal :sidekiqtests, first_span[:data][:sdk][:name]
+    first_span = spans[1]
+    second_span = spans[0]
 
-    assert_equal first_span.id, second_span[:p]
+    assert_equal first_span[:s], second_span[:p]
+    validate_sdk_span(first_span, {:name => :sidekiqtests, :type => :intermediate})
 
     assert_equal :'sidekiq-client', second_span[:n]
     assert_equal true, second_span[:error]

data/test/instrumentation/sidekiq-worker_test.rb

@@ -30,8 +30,9 @@ class SidekiqServerTest < Minitest::Test
     enable_redis_instrumentation
     sleep 1
 
-    assert_equal 1, ::Instana.processor.queue_count
-    assert_successful_worker_trace(::Instana.processor.queued_traces.first)
+    spans = Instana.processor.queued_spans
+    worker_span = find_spans_by_name(spans, :'sidekiq-worker').first
+    assert_successful_worker_span(worker_span)
 
     $sidekiq_mode = :client
   end
@@ -59,8 +60,10 @@ class SidekiqServerTest < Minitest::Test
     enable_redis_instrumentation
 
     sleep 1
-    assert_equal 1, ::Instana.processor.queue_count
-    assert_failed_worker_trace(::Instana.processor.queued_traces.first)
+
+    spans = Instana.processor.queued_spans
+    worker_span = find_spans_by_name(spans, :'sidekiq-worker').first
+    assert_failed_worker_span(worker_span)
 
     $sidekiq_mode = :client
   end
@@ -80,15 +83,20 @@ class SidekiqServerTest < Minitest::Test
       enable_redis_instrumentation
     end
     sleep 1
-    assert_equal 2, ::Instana.processor.queue_count
-    client_trace, worker_trace = differentiate_trace(
-      Instana.processor.queued_traces.to_a
-    )
-    assert_client_trace(client_trace, ::SidekiqJobOne)
-    assert_successful_worker_trace(worker_trace)
+    spans = Instana.processor.queued_spans
+
+    sdk_span = find_spans_by_name(spans, :sidekiqtests).first
+    validate_sdk_span(sdk_span)
+
+    client_span = find_spans_by_name(spans, :'sidekiq-client').first
+    assert_client_span(client_span, ::SidekiqJobOne)
+
+    worker_span = find_spans_by_name(spans, :'sidekiq-worker').first
+    assert_successful_worker_span(worker_span)
 
     # Worker trace and client trace are in the same trace
-    assert_equal client_trace.spans.first['t'], worker_trace.spans.first['t']
+    assert_equal worker_span[:t], client_span[:t]
+    assert_equal worker_span[:p], client_span[:s]
 
     $sidekiq_mode = :client
   end
@@ -108,15 +116,21 @@ class SidekiqServerTest < Minitest::Test
       enable_redis_instrumentation
     end
     sleep 1
-    assert_equal 2, ::Instana.processor.queue_count
-    client_trace, worker_trace = differentiate_trace(
-      Instana.processor.queued_traces.to_a
-    )
-    assert_client_trace(client_trace, ::SidekiqJobTwo)
-    assert_failed_worker_trace(worker_trace)
+
+    spans = Instana.processor.queued_spans
+
+    sdk_span = find_spans_by_name(spans, :sidekiqtests).first
+    validate_sdk_span(sdk_span)
+
+    client_span = find_spans_by_name(spans, :'sidekiq-client').first
+    assert_client_span(client_span, ::SidekiqJobTwo)
+
+    worker_span = find_spans_by_name(spans, :'sidekiq-worker').first
+    assert_failed_worker_span(worker_span)
 
     # Worker trace and client trace are in the same trace
-    assert_equal client_trace.spans.first['t'], worker_trace.spans.first['t']
+    assert_equal worker_span[:t], client_span[:t]
+    assert_equal worker_span[:p], client_span[:s]
 
     $sidekiq_mode = :client
   end
@@ -132,57 +146,28 @@ class SidekiqServerTest < Minitest::Test
     end
   end
 
-  def differentiate_trace(traces)
-    trying_client = traces[0]
-    trying_server = traces[1]
-
-    try_successfully = trying_client.spans.any? do |span|
-      span.name == :'sidekiq-client'
-    end
+  def assert_successful_worker_span(worker_span)
+    assert_equal :'sidekiq-worker', worker_span[:n]
 
-    if try_successfully
-      [trying_client, trying_server]
-    else
-      [trying_server, trying_client]
-    end
+    assert_equal 'important', worker_span[:data][:'sidekiq-worker'][:queue]
+    assert_equal 'SidekiqJobOne', worker_span[:data][:'sidekiq-worker'][:job]
+    assert_equal false, worker_span[:data][:'sidekiq-worker'][:job_id].nil?
   end
 
-  def assert_successful_worker_trace(worker_trace)
-    assert_equal 1, worker_trace.spans.length
-    span = worker_trace.spans.first
+  def assert_failed_worker_span(worker_span)
+    assert_equal :'sidekiq-worker', worker_span[:n]
 
-    assert_equal :'sidekiq-worker', span[:n]
+    assert_equal 'important', worker_span[:data][:'sidekiq-worker'][:queue]
+    assert_equal 'SidekiqJobTwo', worker_span[:data][:'sidekiq-worker'][:job]
+    assert_equal false, worker_span[:data][:'sidekiq-worker'][:job_id].nil?
 
-    assert_equal 'important', span[:data][:'sidekiq-worker'][:queue]
-    assert_equal 'SidekiqJobOne', span[:data][:'sidekiq-worker'][:job]
-    assert_equal false, span[:data][:'sidekiq-worker'][:job_id].nil?
+    assert_equal true, worker_span[:data][:'sidekiq-worker'][:error]
+    assert_equal 'Fail to execute the job', worker_span[:data][:log][:message]
   end
 
-  def assert_failed_worker_trace(worker_trace)
-    assert_equal 1, worker_trace.spans.length
-    span = worker_trace.spans.first
-
-    assert_equal :'sidekiq-worker', span[:n]
-
-    assert_equal 'important', span[:data][:'sidekiq-worker'][:queue]
-    assert_equal 'SidekiqJobTwo', span[:data][:'sidekiq-worker'][:job]
-    assert_equal false, span[:data][:'sidekiq-worker'][:job_id].nil?
-
-    assert_equal true, span[:data][:'sidekiq-worker'][:error]
-    assert_equal 'Fail to execute the job', span[:data][:log][:message]
-  end
-
-  def assert_client_trace(client_trace, job)
-    assert_equal 2, client_trace.spans.length
-    first_span, second_span = client_trace.spans.to_a
-
-    assert_equal :sdk, first_span[:n]
-    assert_equal :sidekiqtests, first_span[:data][:sdk][:name]
-
-    assert_equal first_span.id, second_span[:p]
-
-    assert_equal :'sidekiq-client', second_span[:n]
-    assert_equal 'important', second_span[:data][:'sidekiq-client'][:queue]
-    assert_equal job.name, second_span[:data][:'sidekiq-client'][:job]
+  def assert_client_span(client_span, job)
+    assert_equal :'sidekiq-client', client_span[:n]
+    assert_equal 'important', client_span[:data][:'sidekiq-client'][:queue]
+    assert_equal job.name, client_span[:data][:'sidekiq-client'][:job]
   end
 end