Debian Codegraph @

exporters/otlp/otlptrace/otlptracegrpc/mock_collector_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package otlptracegrpc_test
5
6 import (
7 "context"
8 "fmt"
9 "net"
10 "sync"
11 "testing"
12
13 "github.com/stretchr/testify/require"
14 collectortracepb "go.opentelemetry.io/proto/otlp/collector/trace/v1"
15 tracepb "go.opentelemetry.io/proto/otlp/trace/v1"
16 "google.golang.org/grpc"
17 "google.golang.org/grpc/metadata"
18
19 "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlptracetest"
20 )
21
22 func makeMockCollector(t testing.TB, mockConfig *mockConfig) *mockCollector {
23 return &mockCollector{
24 t: t,
25 traceSvc: &mockTraceService{
26 storage: otlptracetest.NewSpansStorage(),
27 errors: mockConfig.errors,
28 partial: mockConfig.partial,
29 },
30 stopped: make(chan struct{}),
31 }
32 }
33
34 type mockTraceService struct {
35 collectortracepb.UnimplementedTraceServiceServer
36
37 errors []error
38 partial *collectortracepb.ExportTracePartialSuccess
39 requests int
40 mu sync.RWMutex
41 storage otlptracetest.SpansStorage
42 headers metadata.MD
43 exportBlock chan struct{}
44 }
45
46 func (mts *mockTraceService) getHeaders() metadata.MD {
47 mts.mu.RLock()
48 defer mts.mu.RUnlock()
49 return mts.headers
50 }
51
52 func (mts *mockTraceService) getSpans() []*tracepb.Span {
53 mts.mu.RLock()
54 defer mts.mu.RUnlock()
55 return mts.storage.GetSpans()
56 }
57
58 func (mts *mockTraceService) getResourceSpans() []*tracepb.ResourceSpans {
59 mts.mu.RLock()
60 defer mts.mu.RUnlock()
61 return mts.storage.GetResourceSpans()
62 }
63
64 func (mts *mockTraceService) Export(
65 ctx context.Context,
66 exp *collectortracepb.ExportTraceServiceRequest,
67 ) (*collectortracepb.ExportTraceServiceResponse, error) {
68 mts.mu.Lock()
69 defer func() {
70 mts.requests++
71 mts.mu.Unlock()
72 }()
73
74 if mts.exportBlock != nil {
75 // Do this with the lock held so the mockCollector.Stop does not
76 // abandon cleaning up resources.
77 <-mts.exportBlock
78 }
79
80 reply := &collectortracepb.ExportTraceServiceResponse{
81 PartialSuccess: mts.partial,
82 }
83 if mts.requests < len(mts.errors) {
84 idx := mts.requests
85 return reply, mts.errors[idx]
86 }
87
88 mts.headers, _ = metadata.FromIncomingContext(ctx)
89 mts.storage.AddSpans(exp)
90 return reply, nil
91 }
92
93 type mockCollector struct {
94 t testing.TB
95
96 traceSvc *mockTraceService
97
98 endpoint string
99 stopFunc func()
100 stopOnce sync.Once
101 stopped chan struct{}
102 }
103
104 type mockConfig struct {
105 errors []error
106 endpoint string
107 partial *collectortracepb.ExportTracePartialSuccess
108 }
109
110 var _ collectortracepb.TraceServiceServer = (*mockTraceService)(nil)
111
112 var errAlreadyStopped = fmt.Errorf("already stopped")
113
114 func (mc *mockCollector) stop() error {
115 err := errAlreadyStopped
116 mc.stopOnce.Do(func() {
117 err = nil
118 if mc.stopFunc != nil {
119 mc.stopFunc()
120 }
121 })
122 // Wait until gRPC server is down.
123 <-mc.stopped
124
125 // Getting the lock ensures the traceSvc is done flushing.
126 mc.traceSvc.mu.Lock()
127 defer mc.traceSvc.mu.Unlock()
128
129 return err
130 }
131
132 func (mc *mockCollector) Stop() error {
133 return mc.stop()
134 }
135
136 func (mc *mockCollector) getSpans() []*tracepb.Span {
137 return mc.traceSvc.getSpans()
138 }
139
140 func (mc *mockCollector) getResourceSpans() []*tracepb.ResourceSpans {
141 return mc.traceSvc.getResourceSpans()
142 }
143
144 func (mc *mockCollector) GetResourceSpans() []*tracepb.ResourceSpans {
145 return mc.getResourceSpans()
146 }
147
148 func (mc *mockCollector) getHeaders() metadata.MD {
149 return mc.traceSvc.getHeaders()
150 }
151
152 // runMockCollector is a helper function to create a mock Collector.
153 func runMockCollector(tb testing.TB) *mockCollector {
154 tb.Helper()
155 return runMockCollectorAtEndpoint(tb, "localhost:0")
156 }
157
158 func runMockCollectorAtEndpoint(tb testing.TB, endpoint string) *mockCollector {
159 tb.Helper()
160 return runMockCollectorWithConfig(tb, &mockConfig{endpoint: endpoint})
161 }
162
163 func runMockCollectorWithConfig(tb testing.TB, mockConfig *mockConfig) *mockCollector {
164 tb.Helper()
165 ln, err := (&net.ListenConfig{}).Listen(tb.Context(), "tcp", mockConfig.endpoint)
166 require.NoError(tb, err, "net.Listen")
167
168 srv := grpc.NewServer()
169 mc := makeMockCollector(tb, mockConfig)
170 collectortracepb.RegisterTraceServiceServer(srv, mc.traceSvc)
171 go func() {
172 _ = srv.Serve(ln)
173 close(mc.stopped)
174 }()
175
176 mc.endpoint = ln.Addr().String()
177 mc.stopFunc = srv.Stop
178 return mc
179 }