Debian Codegraph @

exporters/zipkin/zipkin_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package zipkin
5
6 import (
7 "bytes"
8 "context"
9 "encoding/json"
10 "fmt"
11 "io"
12 "log"
13 "net"
14 "net/http"
15 "net/http/httptest"
16 "sync"
17 "testing"
18 "time"
19
20 "github.com/go-logr/logr/funcr"
21 zkmodel "github.com/openzipkin/zipkin-go/model"
22 "github.com/stretchr/testify/assert"
23 "github.com/stretchr/testify/require"
24
25 "go.opentelemetry.io/otel/codes"
26 "go.opentelemetry.io/otel/sdk/resource"
27 sdktrace "go.opentelemetry.io/otel/sdk/trace"
28 "go.opentelemetry.io/otel/sdk/trace/tracetest"
29 semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
30 "go.opentelemetry.io/otel/trace"
31 )
32
33 func TestNewRawExporter(t *testing.T) {
34 _, err := New(
35 defaultCollectorURL,
36 )
37
38 assert.NoError(t, err)
39 }
40
41 func TestNewRawExporterShouldFailInvalidCollectorURL(t *testing.T) {
42 var (
43 exp *Exporter
44 err error
45 )
46
47 // invalid URL
48 exp, err = New(
49 "localhost",
50 )
51
52 assert.Error(t, err)
53 assert.EqualError(t, err, "invalid collector URL \"localhost\": no scheme or host")
54 assert.Nil(t, exp)
55 }
56
57 func TestNewRawExporterEmptyDefaultCollectorURL(t *testing.T) {
58 var (
59 exp *Exporter
60 err error
61 )
62
63 // use default collector URL if not specified
64 exp, err = New("")
65
66 assert.NoError(t, err)
67 assert.Equal(t, defaultCollectorURL, exp.url)
68 }
69
70 func TestNewRawExporterCollectorURLFromEnv(t *testing.T) {
71 var (
72 exp *Exporter
73 err error
74 )
75
76 expectedEndpoint := "http://localhost:19411/api/v2/spans"
77 t.Setenv(envEndpoint, expectedEndpoint)
78
79 exp, err = New("")
80
81 assert.NoError(t, err)
82 assert.Equal(t, expectedEndpoint, exp.url)
83 }
84
85 type mockZipkinCollector struct {
86 t *testing.T
87 url string
88 closing bool
89 server *http.Server
90 wg *sync.WaitGroup
91
92 lock sync.RWMutex
93 models []zkmodel.SpanModel
94 }
95
96 func startMockZipkinCollector(t *testing.T) *mockZipkinCollector {
97 collector := &mockZipkinCollector{
98 t: t,
99 closing: false,
100 }
101 listener, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", "127.0.0.1:0")
102 require.NoError(t, err)
103 collector.url = fmt.Sprintf("http://%s", listener.Addr().String())
104 server := &http.Server{
105 Handler: http.HandlerFunc(collector.handler),
106 ReadTimeout: 10 * time.Second,
107 WriteTimeout: 10 * time.Second,
108 }
109 collector.server = server
110 wg := &sync.WaitGroup{}
111 wg.Add(1)
112 collector.wg = wg
113 go func() {
114 err := server.Serve(listener)
115 require.True(t, collector.closing)
116 require.Equal(t, http.ErrServerClosed, err)
117 wg.Done()
118 }()
119
120 return collector
121 }
122
123 func (c *mockZipkinCollector) handler(w http.ResponseWriter, r *http.Request) {
124 jsonBytes, err := io.ReadAll(r.Body)
125 require.NoError(c.t, err)
126 var models []zkmodel.SpanModel
127 err = json.Unmarshal(jsonBytes, &models)
128 require.NoError(c.t, err)
129 // for some reason we may get the nonUTC timestamps in models,
130 // fix that
131 for midx := range models {
132 models[midx].Timestamp = models[midx].Timestamp.UTC()
133 for aidx := range models[midx].Annotations {
134 models[midx].Annotations[aidx].Timestamp = models[midx].Annotations[aidx].Timestamp.UTC()
135 }
136 }
137 c.lock.Lock()
138 defer c.lock.Unlock()
139 c.models = append(c.models, models...)
140 w.WriteHeader(http.StatusAccepted)
141 }
142
143 func (c *mockZipkinCollector) Close() {
144 if c.closing {
145 return
146 }
147 c.closing = true
148 server := c.server
149 c.server = nil
150 require.NoError(c.t, server.Shutdown(c.t.Context()))
151 c.wg.Wait()
152 }
153
154 func (c *mockZipkinCollector) ModelsLen() int {
155 c.lock.RLock()
156 defer c.lock.RUnlock()
157 return len(c.models)
158 }
159
160 func (c *mockZipkinCollector) StealModels() []zkmodel.SpanModel {
161 c.lock.Lock()
162 defer c.lock.Unlock()
163 models := c.models
164 c.models = nil
165 return models
166 }
167
168 type logStore struct {
169 T *testing.T
170 Messages []string
171 }
172
173 func (s *logStore) Write(p []byte) (n int, err error) {
174 msg := string(p)
175 if s.T != nil {
176 s.T.Logf("%s", msg)
177 }
178 s.Messages = append(s.Messages, msg)
179 return len(p), nil
180 }
181
182 func logStoreLogger(s *logStore) *log.Logger {
183 return log.New(s, "", 0)
184 }
185
186 func TestExportSpans(t *testing.T) {
187 res := resource.NewSchemaless(
188 semconv.ServiceName("exporter-test"),
189 semconv.ServiceVersion("0.1.0"),
190 )
191
192 spans := tracetest.SpanStubs{
193 // parent
194 {
195 SpanContext: trace.NewSpanContext(trace.SpanContextConfig{
196 TraceID: trace.TraceID{
197 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
198 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
199 },
200 SpanID: trace.SpanID{0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8},
201 }),
202 SpanKind: trace.SpanKindServer,
203 Name: "foo",
204 StartTime: time.Date(2020, time.March, 11, 19, 24, 0, 0, time.UTC),
205 EndTime: time.Date(2020, time.March, 11, 19, 25, 0, 0, time.UTC),
206 Attributes: nil,
207 Events: nil,
208 Status: sdktrace.Status{
209 Code: codes.Error,
210 Description: "404, file not found",
211 },
212 Resource: res,
213 },
214 // child
215 {
216 SpanContext: trace.NewSpanContext(trace.SpanContextConfig{
217 TraceID: trace.TraceID{
218 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
219 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
220 },
221 SpanID: trace.SpanID{0xDF, 0xDE, 0xDD, 0xDC, 0xDB, 0xDA, 0xD9, 0xD8},
222 }),
223 Parent: trace.NewSpanContext(trace.SpanContextConfig{
224 TraceID: trace.TraceID{
225 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
226 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
227 },
228 SpanID: trace.SpanID{0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8},
229 }),
230 SpanKind: trace.SpanKindServer,
231 Name: "bar",
232 StartTime: time.Date(2020, time.March, 11, 19, 24, 15, 0, time.UTC),
233 EndTime: time.Date(2020, time.March, 11, 19, 24, 45, 0, time.UTC),
234 Attributes: nil,
235 Events: nil,
236 Status: sdktrace.Status{
237 Code: codes.Error,
238 Description: "403, forbidden",
239 },
240 Resource: res,
241 },
242 }.Snapshots()
243 models := []zkmodel.SpanModel{
244 // model of parent
245 {
246 SpanContext: zkmodel.SpanContext{
247 TraceID: zkmodel.TraceID{
248 High: 0x001020304050607,
249 Low: 0x8090a0b0c0d0e0f,
250 },
251 ID: zkmodel.ID(0xfffefdfcfbfaf9f8),
252 ParentID: nil,
253 Debug: false,
254 Sampled: nil,
255 Err: nil,
256 },
257 Name: "foo",
258 Kind: "SERVER",
259 Timestamp: time.Date(2020, time.March, 11, 19, 24, 0, 0, time.UTC),
260 Duration: time.Minute,
261 Shared: false,
262 LocalEndpoint: &zkmodel.Endpoint{
263 ServiceName: "exporter-test",
264 },
265 RemoteEndpoint: nil,
266 Annotations: nil,
267 Tags: map[string]string{
268 "otel.status_code": "ERROR",
269 "error": "404, file not found",
270 "service.name": "exporter-test",
271 "service.version": "0.1.0",
272 },
273 },
274 // model of child
275 {
276 SpanContext: zkmodel.SpanContext{
277 TraceID: zkmodel.TraceID{
278 High: 0x001020304050607,
279 Low: 0x8090a0b0c0d0e0f,
280 },
281 ID: zkmodel.ID(0xdfdedddcdbdad9d8),
282 ParentID: zkmodelIDPtr(0xfffefdfcfbfaf9f8),
283 Debug: false,
284 Sampled: nil,
285 Err: nil,
286 },
287 Name: "bar",
288 Kind: "SERVER",
289 Timestamp: time.Date(2020, time.March, 11, 19, 24, 15, 0, time.UTC),
290 Duration: 30 * time.Second,
291 Shared: false,
292 LocalEndpoint: &zkmodel.Endpoint{
293 ServiceName: "exporter-test",
294 },
295 RemoteEndpoint: nil,
296 Annotations: nil,
297 Tags: map[string]string{
298 "otel.status_code": "ERROR",
299 "error": "403, forbidden",
300 "service.name": "exporter-test",
301 "service.version": "0.1.0",
302 },
303 },
304 }
305 require.Len(t, models, len(spans))
306 collector := startMockZipkinCollector(t)
307 defer collector.Close()
308 ls := &logStore{T: t}
309 logger := logStoreLogger(ls)
310 exporter, err := New(collector.url, WithLogger(logger))
311 require.NoError(t, err)
312 ctx := t.Context()
313 require.Empty(t, ls.Messages)
314 require.NoError(t, exporter.ExportSpans(ctx, spans[0:1]))
315 require.Len(t, ls.Messages, 1)
316 require.Contains(t, ls.Messages[0], "send a POST request")
317 ls.Messages = nil
318 require.NoError(t, exporter.ExportSpans(ctx, nil))
319 require.Len(t, ls.Messages, 1)
320 require.Contains(t, ls.Messages[0], "no spans to export")
321 ls.Messages = nil
322 require.NoError(t, exporter.ExportSpans(ctx, spans[1:2]))
323 require.Contains(t, ls.Messages[0], "send a POST request")
324 checkFunc := func() bool {
325 return collector.ModelsLen() == len(models)
326 }
327 require.Eventually(t, checkFunc, time.Second, 10*time.Millisecond)
328 require.Equal(t, models, collector.StealModels())
329 }
330
331 func TestExporterShutdownHonorsTimeout(t *testing.T) {
332 ctx, cancel := context.WithTimeout(t.Context(), 1*time.Minute)
333 defer cancel()
334
335 exp, err := New("")
336 require.NoError(t, err)
337
338 innerCtx, innerCancel := context.WithTimeout(ctx, time.Nanosecond)
339 defer innerCancel()
340 <-innerCtx.Done()
341 assert.Errorf(t, exp.Shutdown(innerCtx), context.DeadlineExceeded.Error())
342 }
343
344 func TestExporterShutdownHonorsCancel(t *testing.T) {
345 ctx, cancel := context.WithTimeout(t.Context(), 1*time.Minute)
346 defer cancel()
347
348 exp, err := New("")
349 require.NoError(t, err)
350
351 innerCtx, innerCancel := context.WithCancel(ctx)
352 innerCancel()
353 assert.Errorf(t, exp.Shutdown(innerCtx), context.Canceled.Error())
354 }
355
356 func TestErrorOnExportShutdownExporter(t *testing.T) {
357 exp, err := New("")
358 require.NoError(t, err)
359 assert.NoError(t, exp.Shutdown(t.Context()))
360 assert.NoError(t, exp.ExportSpans(t.Context(), nil))
361 }
362
363 func TestLogrFormatting(t *testing.T) {
364 format := "string %q, int %d"
365 args := []any{"s", 1}
366
367 var buf bytes.Buffer
368 l := funcr.New(func(prefix, args string) {
369 _, _ = fmt.Fprint(&buf, prefix, args)
370 }, funcr.Options{})
371 exp, err := New("", WithLogr(l))
372 require.NoError(t, err)
373
374 exp.logf(format, args...)
375
376 want := "\"level\"=0 \"msg\"=\"string \\\"s\\\", int 1\""
377 got := buf.String()
378 assert.Equal(t, want, got)
379 }
380
381 func TestWithHeaders(t *testing.T) {
382 headers := map[string]string{
383 "name1": "value1",
384 "name2": "value2",
385 "host": "example",
386 }
387
388 exp, err := New("", WithHeaders(headers))
389 require.NoError(t, err)
390
391 want := headers
392 got := exp.headers
393 assert.Equal(t, want, got)
394
395 spans := tracetest.SpanStubs{
396 {
397 SpanContext: trace.NewSpanContext(trace.SpanContextConfig{
398 TraceID: trace.TraceID{
399 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
400 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
401 },
402 SpanID: trace.SpanID{0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8},
403 }),
404 },
405 }.Snapshots()
406
407 var req *http.Request
408 handler := func(w http.ResponseWriter, r *http.Request) {
409 req = r
410 w.WriteHeader(http.StatusOK)
411 }
412
413 srv := httptest.NewServer(http.HandlerFunc(handler))
414 defer srv.Close()
415
416 e := &Exporter{
417 url: srv.URL,
418 client: srv.Client(),
419 headers: headers,
420 }
421
422 _ = e.ExportSpans(t.Context(), spans)
423
424 assert.Equal(t, headers["host"], req.Host)
425 assert.Equal(t, headers["name1"], req.Header.Get("name1"))
426 assert.Equal(t, headers["name2"], req.Header.Get("name2"))
427 }
428
429 func TestWithClient(t *testing.T) {
430 customClient := &http.Client{
431 Timeout: 1000,
432 }
433
434 testcases := []struct {
435 name string
436 client *http.Client
437 want *http.Client
438 description string
439 }{
440 {
441 name: "nil client",
442 client: nil,
443 want: http.DefaultClient,
444 description: "should fall back to default client when nil is provided",
445 },
446 {
447 name: "custom client",
448 client: customClient,
449 want: customClient,
450 description: "should use provided custom client",
451 },
452 }
453
454 for _, tc := range testcases {
455 t.Run(tc.name, func(t *testing.T) {
456 exp, err := New("", WithClient(tc.client))
457 require.NoError(t, err)
458
459 assert.Equal(t, tc.want, exp.client)
460 })
461 }
462 }