instana 1.1.0 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (55) hide show
  1. checksums.yaml +4 -4
  2. data/.codeclimate.yml +2 -0
  3. data/.gitignore +1 -0
  4. data/.travis.yml +24 -2
  5. data/Gemfile +2 -22
  6. data/README.md +1 -1
  7. data/Rakefile +15 -0
  8. data/Tracing.md +29 -2
  9. data/gemfiles/libraries.gemfile +50 -0
  10. data/gemfiles/rails32.gemfile +45 -0
  11. data/gemfiles/rails42.gemfile +44 -0
  12. data/gemfiles/rails50.gemfile +44 -0
  13. data/instana.gemspec +6 -8
  14. data/lib/instana/config.rb +7 -5
  15. data/lib/instana/frameworks/instrumentation/abstract_mysql_adapter.rb +55 -0
  16. data/lib/instana/frameworks/instrumentation/action_controller.rb +105 -0
  17. data/lib/instana/frameworks/instrumentation/active_record.rb +22 -0
  18. data/lib/instana/frameworks/instrumentation/mysql2_adapter.rb +81 -0
  19. data/lib/instana/frameworks/instrumentation/mysql_adapter.rb +56 -0
  20. data/lib/instana/frameworks/instrumentation/postgresql_adapter.rb +71 -0
  21. data/lib/instana/frameworks/rails.rb +5 -0
  22. data/lib/instana/test.rb +40 -0
  23. data/lib/instana/tracer.rb +19 -0
  24. data/lib/instana/tracing/span.rb +3 -3
  25. data/lib/instana/version.rb +1 -1
  26. data/log/.keep +0 -0
  27. data/test/agent/agent_test.rb +139 -0
  28. data/test/apps/cuba.rb +15 -0
  29. data/test/apps/roda.rb +10 -0
  30. data/test/apps/sinatra.rb +5 -0
  31. data/test/config_test.rb +17 -0
  32. data/test/frameworks/cuba_test.rb +44 -0
  33. data/test/frameworks/rack_test.rb +152 -0
  34. data/test/frameworks/rails/actioncontroller_test.rb +123 -0
  35. data/test/frameworks/rails/activerecord3_test.rb +134 -0
  36. data/test/frameworks/rails/activerecord4_test.rb +134 -0
  37. data/test/frameworks/rails/activerecord5_test.rb +90 -0
  38. data/test/frameworks/roda_test.rb +44 -0
  39. data/test/frameworks/sinatra_test.rb +44 -0
  40. data/test/instana_test.rb +27 -0
  41. data/test/instrumentation/dalli_test.rb +274 -0
  42. data/test/instrumentation/excon_test.rb +171 -0
  43. data/test/instrumentation/net-http_test.rb +140 -0
  44. data/test/instrumentation/rest-client_test.rb +61 -0
  45. data/test/models/block.rb +18 -0
  46. data/test/servers/rackapp_6511.rb +20 -0
  47. data/test/servers/rails_3205.rb +95 -0
  48. data/test/test_helper.rb +39 -0
  49. data/test/tracing/custom_test.rb +143 -0
  50. data/test/tracing/id_management_test.rb +96 -0
  51. data/test/tracing/opentracing_test.rb +377 -0
  52. data/test/tracing/trace_test.rb +50 -0
  53. data/test/tracing/tracer_async_test.rb +298 -0
  54. data/test/tracing/tracer_test.rb +202 -0
  55. metadata +114 -4
@@ -0,0 +1,50 @@
1
+ require 'test_helper'
2
+
3
+ class TraceTest < Minitest::Test
4
+ def test_trace_spans_count
5
+ t = ::Instana::Trace.new(:test_trace, { :one => 1, :two => 2 })
6
+ t.new_span(:sub_span, { :sub_four => 4 })
7
+ t.end_span(:sub_five => 5)
8
+ t.end_span(:three => 3)
9
+ assert t.spans.size == 2
10
+ end
11
+
12
+ def test_trace_with_incoming_context
13
+ incoming_context = { :trace_id => "1234", :span_id => "4321" }
14
+ t = ::Instana::Trace.new(:test_trace, { :one => 1, :two => 2 }, incoming_context)
15
+ first_span = t.spans.first
16
+ assert_equal "1234", first_span[:t]
17
+ assert_equal "4321", first_span[:p]
18
+ assert t.spans.size == 1
19
+ end
20
+
21
+ def test_max_value_of_generated_id
22
+ # Max is the maximum value for a Java signed long
23
+ max_value = 9223372036854775807
24
+ 1000.times do
25
+ assert ::Instana::Util.generate_id <= max_value
26
+ end
27
+ end
28
+
29
+ def test_min_value_of_generated_id
30
+ # Max is the maximum value for a Java signed long
31
+ max_value = -9223372036854775808
32
+ 1000.times do
33
+ assert ::Instana::Util.generate_id >= max_value
34
+ end
35
+ end
36
+
37
+ def test_entry_span_has_stack_with_limit
38
+ t = ::Instana::Trace.new(:rack)
39
+ first_span = t.spans.first
40
+ assert first_span.key?(:stack)
41
+ assert_equal 2, first_span[:stack].count
42
+ end
43
+
44
+ def test_exit_span_has_stack
45
+ t = ::Instana::Trace.new(:trace_test)
46
+ t.new_span(:excon)
47
+ second_span = t.spans.to_a[1]
48
+ assert second_span.key?(:stack)
49
+ end
50
+ end
@@ -0,0 +1,298 @@
1
+ require 'test_helper'
2
+
3
+ class TracerAsyncTest < Minitest::Test
4
+ def test_same_thread_async_tracing
5
+ clear_all!
6
+
7
+ # Start tracing
8
+ ::Instana.tracer.log_start_or_continue(:rack, {:rack_start_kv => 1})
9
+
10
+ # Start an asynchronous span
11
+ span = ::Instana.tracer.log_async_entry(:my_async_op, { :entry_kv => 1})
12
+
13
+ refute_nil span
14
+ refute_nil span.context
15
+
16
+ # Current span should still be rack
17
+ assert_equal :rack, ::Instana.tracer.current_trace.current_span_name
18
+
19
+ # End an asynchronous span
20
+ ::Instana.tracer.log_async_exit(:my_async_op, { :exit_kv => 1 }, span)
21
+
22
+ # Current span should still be rack
23
+ assert_equal :rack, ::Instana.tracer.current_trace.current_span_name
24
+
25
+ # End tracing
26
+ ::Instana.tracer.log_end(:rack, {:rack_end_kv => 1})
27
+
28
+ traces = ::Instana.processor.queued_traces
29
+ assert_equal 1, traces.count
30
+ t = traces.first
31
+ assert_equal 2, t.spans.size
32
+ spans = t.spans.to_a
33
+ first_span = spans[0]
34
+ second_span = spans[1]
35
+
36
+ # Both spans have a duration
37
+ assert first_span[:d]
38
+ assert second_span[:d]
39
+
40
+ # first_span is the parent of first_span
41
+ assert_equal first_span[:s], second_span[:p]
42
+ # same trace id
43
+ assert_equal first_span[:t], second_span[:t]
44
+
45
+ # KV checks
46
+ assert_equal 1, first_span[:data][:rack_start_kv]
47
+ assert_equal 1, first_span[:data][:rack_end_kv]
48
+ assert_equal 1, second_span[:data][:sdk][:custom][:entry_kv]
49
+ assert_equal 1, second_span[:data][:sdk][:custom][:exit_kv]
50
+ end
51
+
52
+ def test_diff_thread_async_tracing
53
+ clear_all!
54
+
55
+ # Start tracing
56
+ ::Instana.tracer.log_start_or_continue(:rack, {:rack_start_kv => 1})
57
+
58
+ t_context = ::Instana.tracer.context
59
+ refute_nil t_context.trace_id
60
+ refute_nil t_context.span_id
61
+
62
+ Thread.new do
63
+ ::Instana.tracer.log_start_or_continue(:async_thread, { :async_start => 1 }, t_context.to_hash)
64
+ ::Instana.tracer.log_entry(:sleepy_time, { :tired => 1 })
65
+ # Sleep beyond the end of this root trace
66
+ sleep 0.5
67
+ ::Instana.tracer.log_exit(:sleepy_time, { :wake_up => 1})
68
+ ::Instana.tracer.log_end(:async_thread, { :async_end => 1 })
69
+ end
70
+
71
+ # Current span should still be rack
72
+ assert_equal :rack, ::Instana.tracer.current_trace.current_span_name
73
+
74
+ # End tracing
75
+ ::Instana.tracer.log_end(:rack, {:rack_end_kv => 1})
76
+
77
+ assert_equal false, ::Instana.tracer.tracing?
78
+
79
+ # Sleep for 1 seconds to wait for the async thread to finish
80
+ sleep 1
81
+
82
+ traces = ::Instana.processor.queued_traces
83
+ assert_equal 2, traces.count
84
+ first_trace, second_trace = traces
85
+
86
+ # Both traces should have the same ID
87
+ assert first_trace.id == second_trace.id
88
+
89
+ # Validate the first original thread span
90
+ assert_equal 1, first_trace.spans.size
91
+ spans = first_trace.spans.to_a
92
+ first_span = spans[0]
93
+ assert_equal :rack, first_span.name
94
+ assert first_span.duration
95
+ assert_equal 1, first_span[:data][:rack_start_kv]
96
+ assert_equal 1, first_span[:data][:rack_end_kv]
97
+
98
+ # Validate the second background thread trace
99
+ assert_equal 2, second_trace.spans.size
100
+ spans = second_trace.spans.to_a
101
+ first_span, second_span = spans
102
+
103
+ # first span in second trace
104
+ assert_equal :async_thread, first_span.name
105
+ assert first_span.duration
106
+ assert_equal 1, first_span[:data][:sdk][:custom][:async_start]
107
+ assert_equal 1, first_span[:data][:sdk][:custom][:async_end]
108
+
109
+ # second span in second trace
110
+ assert_equal :sleepy_time, second_span.name
111
+ assert second_span.duration
112
+ assert_equal 1, second_span[:data][:sdk][:custom][:tired]
113
+ assert_equal 1, second_span[:data][:sdk][:custom][:wake_up]
114
+
115
+ # Validate linkage
116
+ # first_span is the parent of first_span
117
+ assert_equal first_span[:s], second_span[:p]
118
+ # same trace id
119
+ assert_equal first_span[:t], second_span[:t]
120
+ end
121
+
122
+ def test_never_ending_async
123
+ clear_all!
124
+
125
+ # Start tracing
126
+ ::Instana.tracer.log_start_or_continue(:rack, {:rack_start_kv => 1})
127
+
128
+ # Start an asynchronous span
129
+ span = ::Instana.tracer.log_async_entry(:my_async_op, { :async_entry_kv => 1})
130
+
131
+ refute_nil span
132
+ refute_nil span.context
133
+
134
+ # Current span should still be rack
135
+ assert_equal :rack, ::Instana.tracer.current_trace.current_span_name
136
+
137
+ # DON'T end the asynchronous span
138
+ # This trace should end up in staging_queue
139
+ # ::Instana.tracer.log_async_exit(:my_async_op, { :exit_kv => 1 }, span)
140
+
141
+ # Current span should still be rack
142
+ assert_equal :rack, ::Instana.tracer.current_trace.current_span_name
143
+
144
+ # End tracing
145
+ ::Instana.tracer.log_end(:rack, {:rack_end_kv => 1})
146
+
147
+ # Make sure everything is settled
148
+ sleep 0.5
149
+
150
+ assert_equal 1, ::Instana.processor.staged_count
151
+ assert_equal 0, ::Instana.processor.queue_count
152
+
153
+ traces = ::Instana.processor.staged_traces
154
+ assert_equal 1, traces.count
155
+
156
+ trace = traces.first
157
+ assert !trace.complete?
158
+ assert_equal 2, trace.spans.size
159
+ first_span, second_span = trace.spans.to_a
160
+
161
+ # First span should have a duration, second span should NOT
162
+ assert first_span.duration
163
+ assert !second_span.duration
164
+
165
+ # First span validation
166
+ assert_equal :rack, first_span.name
167
+ assert_equal 1, first_span[:data][:rack_start_kv]
168
+ assert_equal 1, first_span[:data][:rack_end_kv]
169
+
170
+ # second span validation
171
+ assert_equal :my_async_op, second_span.name
172
+ assert_equal 1, second_span[:data][:sdk][:custom][:async_entry_kv]
173
+ assert !second_span[:data][:sdk][:custom].key?(:async_exit_kv)
174
+ assert_equal nil, second_span.duration
175
+
176
+ # first_span is the parent of first_span
177
+ assert_equal first_span[:s], second_span[:p]
178
+ # same trace id
179
+ assert_equal first_span[:t], second_span[:t]
180
+ end
181
+
182
+ def test_out_of_order_async_tracing
183
+ clear_all!
184
+
185
+ # Start tracing
186
+ ::Instana.tracer.log_start_or_continue(:rack, {:rack_start_kv => 1})
187
+
188
+ # Start three asynchronous spans
189
+ span1 = ::Instana.tracer.log_async_entry(:my_async_op, { :entry_kv => 1})
190
+ span2 = ::Instana.tracer.log_async_entry(:my_async_op, { :entry_kv => 2})
191
+ span3 = ::Instana.tracer.log_async_entry(:my_async_op, { :entry_kv => 3})
192
+
193
+ # Current span should still be rack
194
+ assert_equal :rack, ::Instana.tracer.current_trace.current_span_name
195
+
196
+ # Log info to the async spans (out of order)
197
+ ::Instana.tracer.log_async_info({ :info_kv => 2 }, span2)
198
+ ::Instana.tracer.log_async_info({ :info_kv => 1 }, span1)
199
+ ::Instana.tracer.log_async_info({ :info_kv => 3 }, span3)
200
+
201
+ # Log out of order errors to the async spans
202
+ ::Instana.tracer.log_async_error(Exception.new("Async span 3"), span3)
203
+ ::Instana.tracer.log_async_error(Exception.new("Async span 2"), span2)
204
+
205
+ # End two out of order asynchronous spans
206
+ ::Instana.tracer.log_async_exit(:my_async_op, { :exit_kv => 3 }, span3)
207
+ ::Instana.tracer.log_async_exit(:my_async_op, { :exit_kv => 2 }, span2)
208
+
209
+ # Current span should still be rack
210
+ assert_equal :rack, ::Instana.tracer.current_trace.current_span_name
211
+
212
+ # End tracing
213
+ ::Instana.tracer.log_end(:rack, {:rack_end_kv => 1})
214
+
215
+ # Log an error to and close out the remaining async span after the parent trace has finished
216
+ ::Instana.tracer.log_async_error(Exception.new("Async span 1"), span1)
217
+ ::Instana.tracer.log_async_exit(:my_async_op, { :exit_kv => 1 }, span1)
218
+
219
+ # Run process_staged to move staged complete traces to main queue
220
+ ::Instana.processor.process_staged
221
+
222
+ # Begin trace validation
223
+ traces = ::Instana.processor.queued_traces
224
+
225
+ assert_equal 1, traces.count
226
+ trace = traces.first
227
+ assert_equal 4, trace.spans.size
228
+ first_span, second_span, third_span, fourth_span = trace.spans.to_a
229
+
230
+ assert trace.complete?
231
+
232
+ # Linkage
233
+ assert_equal first_span[:s], second_span[:p]
234
+ assert_equal first_span[:s], third_span[:p]
235
+ assert_equal first_span[:s], fourth_span[:p]
236
+
237
+ # same trace id
238
+ assert_equal first_span[:t], second_span[:t]
239
+ assert_equal first_span[:t], third_span[:t]
240
+ assert_equal first_span[:t], fourth_span[:t]
241
+
242
+ assert !first_span.custom?
243
+ assert second_span.custom?
244
+ assert third_span.custom?
245
+ assert fourth_span.custom?
246
+
247
+ assert !first_span[:async]
248
+ assert second_span[:async]
249
+ assert third_span[:async]
250
+ assert fourth_span[:async]
251
+
252
+ # KV checks
253
+ assert_equal 1, first_span[:data][:rack_start_kv]
254
+ assert_equal 1, first_span[:data][:rack_end_kv]
255
+ assert_equal 1, second_span[:data][:sdk][:custom][:entry_kv]
256
+ assert_equal 1, second_span[:data][:sdk][:custom][:exit_kv]
257
+ assert_equal 2, third_span[:data][:sdk][:custom][:entry_kv]
258
+ assert_equal 2, third_span[:data][:sdk][:custom][:exit_kv]
259
+ assert_equal 3, fourth_span[:data][:sdk][:custom][:entry_kv]
260
+ assert_equal 3, fourth_span[:data][:sdk][:custom][:exit_kv]
261
+ end
262
+
263
+
264
+ def test_staged_trace_moved_to_queue
265
+ clear_all!
266
+
267
+ # Start tracing
268
+ ::Instana.tracer.log_start_or_continue(:rack, {:rack_start_kv => 1})
269
+
270
+ # Start an asynchronous span
271
+ span = ::Instana.tracer.log_async_entry(:my_async_op, { :async_entry_kv => 1})
272
+
273
+ refute_nil span
274
+ refute_nil span.context
275
+
276
+ # Current span should still be rack
277
+ assert_equal :rack, ::Instana.tracer.current_trace.current_span_name
278
+
279
+ # End tracing with a still outstanding async span (above)
280
+ ::Instana.tracer.log_end(:rack, {:rack_end_kv => 1})
281
+
282
+ # Make sure everything is settled
283
+ sleep 0.5
284
+
285
+ # We should have one staged trace and no queue traces
286
+ assert_equal 1, ::Instana.processor.staged_count
287
+ assert_equal 0, ::Instana.processor.queue_count
288
+
289
+ # Now end the async span completing the trace
290
+ ::Instana.tracer.log_async_exit(:my_async_op, { :exit_kv => 1 }, span)
291
+
292
+ ::Instana.processor.process_staged
293
+
294
+ # We should have one staged trace and no queue traces
295
+ assert_equal 0, ::Instana.processor.staged_count
296
+ assert_equal 1, ::Instana.processor.queue_count
297
+ end
298
+ end
@@ -0,0 +1,202 @@
1
+ require 'test_helper'
2
+
3
+ class TracerTest < Minitest::Test
4
+ def test_that_it_has_a_valid_tracer
5
+ refute_nil ::Instana.tracer
6
+ assert ::Instana.tracer.is_a?(::Instana::Tracer)
7
+ end
8
+
9
+ def test_basic_trace_block
10
+ clear_all!
11
+
12
+ assert_equal false, ::Instana.tracer.tracing?
13
+
14
+ ::Instana.tracer.start_or_continue_trace(:rack, {:one => 1}) do
15
+ assert_equal true, ::Instana.tracer.tracing?
16
+ sleep 0.5
17
+ end
18
+
19
+ traces = ::Instana.processor.queued_traces
20
+ assert_equal 1, traces.count
21
+ t = traces.first
22
+ assert_equal 1, t.spans.size
23
+ assert t.valid?
24
+
25
+ first_span = t.spans.first
26
+ assert_equal :rack, first_span[:n]
27
+ assert_equal :ruby, first_span[:ta]
28
+ assert first_span.key?(:data)
29
+ assert_equal 1, first_span[:data][:one]
30
+ assert first_span.key?(:f)
31
+ assert first_span[:f].key?(:e)
32
+ assert first_span[:f].key?(:h)
33
+ assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
34
+ end
35
+
36
+ def test_errors_are_properly_propogated
37
+ clear_all!
38
+ exception_raised = false
39
+ begin
40
+ ::Instana.tracer.start_or_continue_trace(:rack, {:one => 1}) do
41
+ raise Exception.new('Error in block - this should continue to propogate outside of tracing')
42
+ end
43
+ rescue Exception
44
+ exception_raised = true
45
+ end
46
+
47
+ assert exception_raised
48
+
49
+ traces = ::Instana.processor.queued_traces
50
+ assert_equal 1, traces.count
51
+ t = traces.first
52
+ assert_equal 1, t.spans.size
53
+ assert t.valid?
54
+
55
+ first_span = t.spans.first
56
+ assert_equal :rack, first_span[:n]
57
+ assert_equal :ruby, first_span[:ta]
58
+ assert first_span.key?(:data)
59
+ assert_equal 1, first_span[:data][:one]
60
+ assert first_span.key?(:f)
61
+ assert first_span[:f].key?(:e)
62
+ assert first_span[:f].key?(:h)
63
+ assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
64
+ assert t.has_error?
65
+ end
66
+
67
+ def test_complex_trace_block
68
+ clear_all!
69
+ ::Instana.tracer.start_or_continue_trace(:rack, {:one => 1}) do
70
+ sleep 0.2
71
+ ::Instana.tracer.trace(:sub_block, {:sub_two => 2}) do
72
+ sleep 0.2
73
+ end
74
+ end
75
+
76
+ traces = ::Instana.processor.queued_traces
77
+ assert_equal 1, traces.count
78
+ t = traces.first
79
+ assert_equal 2, t.spans.size
80
+ assert t.valid?
81
+ end
82
+
83
+ def test_basic_low_level_tracing
84
+ clear_all!
85
+
86
+ assert_equal false, ::Instana.tracer.tracing?
87
+ # Start tracing
88
+ ::Instana.tracer.log_start_or_continue(:rack, {:one => 1})
89
+ assert_equal true, ::Instana.tracer.tracing?
90
+ ::Instana.tracer.log_info({:info_logged => 1})
91
+ # End tracing
92
+ ::Instana.tracer.log_end(:rack, {:close_one => 1})
93
+ assert_equal false, ::Instana.tracer.tracing?
94
+
95
+ traces = ::Instana.processor.queued_traces
96
+ assert_equal 1, traces.count
97
+ t = traces.first
98
+ assert_equal 1, t.spans.size
99
+ assert t.valid?
100
+ end
101
+
102
+ def test_complex_low_level_tracing
103
+ clear_all!
104
+
105
+ assert_equal false, ::Instana.tracer.tracing?
106
+
107
+ # Start tracing
108
+ ::Instana.tracer.log_start_or_continue(:rack, {:one => 1})
109
+ assert_equal true, ::Instana.tracer.tracing?
110
+ ::Instana.tracer.log_info({:info_logged => 1})
111
+
112
+ # Start tracing a sub span
113
+ ::Instana.tracer.log_entry(:sub_task)
114
+ assert_equal true, ::Instana.tracer.tracing?
115
+ ::Instana.tracer.log_info({:sub_task_info => 1})
116
+ # Exit from the sub span
117
+ ::Instana.tracer.log_exit(:sub_task, {:sub_task_exit_info => 1})
118
+ assert_equal true, ::Instana.tracer.tracing?
119
+
120
+ # End tracing
121
+ ::Instana.tracer.log_end(:rack, {:close_one => 1})
122
+ assert_equal false, ::Instana.tracer.tracing?
123
+
124
+ traces = ::Instana.processor.queued_traces
125
+ assert_equal 1, traces.count
126
+
127
+ t = traces.first
128
+ assert_equal 2, t.spans.size
129
+ assert t.valid?
130
+
131
+ first_span = t.spans.first
132
+ assert_equal :rack, first_span[:n]
133
+ assert_equal :ruby, first_span[:ta]
134
+ assert first_span.key?(:data)
135
+ assert_equal 1, first_span[:data][:one]
136
+ assert first_span.key?(:f)
137
+ assert first_span[:f].key?(:e)
138
+ assert first_span[:f].key?(:h)
139
+ assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
140
+ end
141
+
142
+ def test_block_tracing_error_capture
143
+ clear_all!
144
+ exception_raised = false
145
+ begin
146
+ ::Instana.tracer.start_or_continue_trace(:test_trace, {:one => 1}) do
147
+ raise Exception.new("Block exception test error")
148
+ end
149
+ rescue Exception
150
+ exception_raised = true
151
+ end
152
+
153
+ assert exception_raised
154
+
155
+ traces = ::Instana.processor.queued_traces
156
+ assert_equal 1, traces.count
157
+
158
+ t = traces.first
159
+ assert_equal 1, t.spans.size
160
+ assert t.valid?
161
+ assert t.has_error?
162
+ end
163
+
164
+ def test_low_level_error_logging
165
+ clear_all!
166
+ ::Instana.tracer.log_start_or_continue(:test_trace, {:one => 1})
167
+ ::Instana.tracer.log_info({:info_logged => 1})
168
+ ::Instana.tracer.log_error(Exception.new("Low level tracing api error"))
169
+ ::Instana.tracer.log_end(:test_trace, {:close_one => 1})
170
+
171
+ traces = ::Instana.processor.queued_traces
172
+ assert_equal 1, traces.count
173
+
174
+ t = traces.first
175
+ assert_equal 1, t.spans.size
176
+ assert t.valid?
177
+ assert t.has_error?
178
+ end
179
+
180
+ def test_instana_headers_in_response
181
+ clear_all!
182
+ ::Instana.tracer.start_or_continue_trace(:rack, {:one => 1}) do
183
+ sleep 0.5
184
+ end
185
+
186
+ traces = ::Instana.processor.queued_traces
187
+ assert_equal 1, traces.count
188
+ t = traces.first
189
+ assert_equal 1, t.spans.size
190
+ assert t.valid?
191
+
192
+ first_span = t.spans.first
193
+ assert_equal :rack, first_span[:n]
194
+ assert_equal :ruby, first_span[:ta]
195
+ assert first_span.key?(:data)
196
+ assert_equal 1, first_span[:data][:one]
197
+ assert first_span.key?(:f)
198
+ assert first_span[:f].key?(:e)
199
+ assert first_span[:f].key?(:h)
200
+ assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
201
+ end
202
+ end