Debian Codegraph @

exporters/otlp/otlptrace/otlptracehttp/mock_collector_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package otlptracehttp_test
5
6 import (
7 "bytes"
8 "compress/gzip"
9 "context"
10 "crypto/tls"
11 "fmt"
12 "io"
13 "net"
14 "net/http"
15 "sync"
16 "testing"
17 "time"
18
19 "github.com/stretchr/testify/assert"
20 "github.com/stretchr/testify/require"
21 collectortracepb "go.opentelemetry.io/proto/otlp/collector/trace/v1"
22 tracepb "go.opentelemetry.io/proto/otlp/trace/v1"
23 "google.golang.org/protobuf/proto"
24
25 "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/internal/otlpconfig"
26 "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/internal/otlptracetest"
27 )
28
29 type mockCollector struct {
30 endpoint string
31 server *http.Server
32
33 spanLock sync.Mutex
34 spansStorage otlptracetest.SpansStorage
35
36 injectHTTPStatus []int
37 injectResponseHeader []map[string]string
38 injectContentType string
39 partial *collectortracepb.ExportTracePartialSuccess
40 delay <-chan struct{}
41
42 clientTLSConfig *tls.Config
43 expectedHeaders map[string]string
44 }
45
46 func (c *mockCollector) Stop() error {
47 return c.server.Shutdown(context.Background())
48 }
49
50 func (c *mockCollector) MustStop(t *testing.T) {
51 assert.NoError(t, c.server.Shutdown(t.Context()))
52 }
53
54 func (c *mockCollector) GetSpans() []*tracepb.Span {
55 c.spanLock.Lock()
56 defer c.spanLock.Unlock()
57 return c.spansStorage.GetSpans()
58 }
59
60 func (c *mockCollector) GetResourceSpans() []*tracepb.ResourceSpans {
61 c.spanLock.Lock()
62 defer c.spanLock.Unlock()
63 return c.spansStorage.GetResourceSpans()
64 }
65
66 func (c *mockCollector) Endpoint() string {
67 return c.endpoint
68 }
69
70 func (c *mockCollector) ClientTLSConfig() *tls.Config {
71 return c.clientTLSConfig
72 }
73
74 func (c *mockCollector) serveTraces(w http.ResponseWriter, r *http.Request) {
75 if c.delay != nil {
76 select {
77 case <-c.delay:
78 case <-r.Context().Done():
79 return
80 }
81 }
82
83 if !c.checkHeaders(r) {
84 w.WriteHeader(http.StatusBadRequest)
85 return
86 }
87 response := collectortracepb.ExportTraceServiceResponse{
88 PartialSuccess: c.partial,
89 }
90 rawResponse, err := proto.Marshal(&response)
91 if err != nil {
92 w.WriteHeader(http.StatusInternalServerError)
93 return
94 }
95 h := c.getInjectResponseHeader()
96 if injectedStatus := c.getInjectHTTPStatus(); injectedStatus != 0 {
97 writeReply(w, rawResponse, injectedStatus, c.injectContentType, h)
98 return
99 }
100 rawRequest, err := readRequest(r)
101 if err != nil {
102 w.WriteHeader(http.StatusInternalServerError)
103 return
104 }
105
106 request, err := unmarshalTraceRequest(rawRequest, r.Header.Get("content-type"))
107 if err != nil {
108 w.WriteHeader(http.StatusBadRequest)
109 return
110 }
111 writeReply(w, rawResponse, 0, c.injectContentType, h)
112 c.spanLock.Lock()
113 defer c.spanLock.Unlock()
114 c.spansStorage.AddSpans(request)
115 }
116
117 func unmarshalTraceRequest(rawRequest []byte, contentType string) (*collectortracepb.ExportTraceServiceRequest, error) {
118 request := &collectortracepb.ExportTraceServiceRequest{}
119 if contentType != "application/x-protobuf" {
120 return request, fmt.Errorf("invalid content-type: %s, only application/x-protobuf is supported", contentType)
121 }
122 err := proto.Unmarshal(rawRequest, request)
123 return request, err
124 }
125
126 func (c *mockCollector) checkHeaders(r *http.Request) bool {
127 for k, v := range c.expectedHeaders {
128 got := r.Header.Get(k)
129 if got != v {
130 return false
131 }
132 }
133 return true
134 }
135
136 func (c *mockCollector) getInjectHTTPStatus() int {
137 if len(c.injectHTTPStatus) == 0 {
138 return 0
139 }
140 status := c.injectHTTPStatus[0]
141 c.injectHTTPStatus = c.injectHTTPStatus[1:]
142 if len(c.injectHTTPStatus) == 0 {
143 c.injectHTTPStatus = nil
144 }
145 return status
146 }
147
148 func (c *mockCollector) getInjectResponseHeader() map[string]string {
149 var h map[string]string
150 if len(c.injectResponseHeader) == 0 {
151 return h
152 }
153 h, c.injectResponseHeader = c.injectResponseHeader[0], c.injectResponseHeader[1:]
154 if len(c.injectResponseHeader) == 0 {
155 c.injectResponseHeader = nil
156 }
157 return h
158 }
159
160 func readRequest(r *http.Request) ([]byte, error) {
161 if r.Header.Get("Content-Encoding") == "gzip" {
162 return readGzipBody(r.Body)
163 }
164 return io.ReadAll(r.Body)
165 }
166
167 func readGzipBody(body io.Reader) ([]byte, error) {
168 rawRequest := bytes.Buffer{}
169 gunzipper, err := gzip.NewReader(body)
170 if err != nil {
171 return nil, err
172 }
173 defer gunzipper.Close()
174 _, err = io.Copy(&rawRequest, gunzipper)
175 if err != nil {
176 return nil, err
177 }
178 return rawRequest.Bytes(), nil
179 }
180
181 func writeReply(w http.ResponseWriter, rawResponse []byte, s int, ct string, h map[string]string) {
182 status := http.StatusOK
183 if s != 0 {
184 status = s
185 }
186 contentType := "application/x-protobuf"
187 if ct != "" {
188 contentType = ct
189 }
190 w.Header().Set("Content-Type", contentType)
191 for k, v := range h {
192 w.Header().Add(k, v)
193 }
194 w.WriteHeader(status)
195 _, _ = w.Write(rawResponse)
196 }
197
198 type mockCollectorConfig struct {
199 TracesURLPath string
200 Port int
201 InjectHTTPStatus []int
202 InjectContentType string
203 InjectResponseHeader []map[string]string
204 Partial *collectortracepb.ExportTracePartialSuccess
205 Delay <-chan struct{}
206 WithTLS bool
207 ExpectedHeaders map[string]string
208 }
209
210 func (c *mockCollectorConfig) fillInDefaults() {
211 if c.TracesURLPath == "" {
212 c.TracesURLPath = otlpconfig.DefaultTracesPath
213 }
214 }
215
216 func runMockCollector(tb testing.TB, cfg mockCollectorConfig) *mockCollector {
217 cfg.fillInDefaults()
218 ln, err := (&net.ListenConfig{}).Listen(tb.Context(), "tcp", fmt.Sprintf("localhost:%d", cfg.Port))
219 require.NoError(tb, err)
220 _, portStr, err := net.SplitHostPort(ln.Addr().String())
221 require.NoError(tb, err)
222 m := &mockCollector{
223 endpoint: fmt.Sprintf("localhost:%s", portStr),
224 spansStorage: otlptracetest.NewSpansStorage(),
225 injectHTTPStatus: cfg.InjectHTTPStatus,
226 injectResponseHeader: cfg.InjectResponseHeader,
227 injectContentType: cfg.InjectContentType,
228 partial: cfg.Partial,
229 delay: cfg.Delay,
230 expectedHeaders: cfg.ExpectedHeaders,
231 }
232 mux := http.NewServeMux()
233 mux.Handle(cfg.TracesURLPath, http.HandlerFunc(m.serveTraces))
234 server := &http.Server{
235 Handler: mux,
236 ReadTimeout: 10 * time.Second,
237 WriteTimeout: 10 * time.Second,
238 }
239 if cfg.WithTLS {
240 pem, err := generateWeakCertificate()
241 require.NoError(tb, err)
242 tlsCertificate, err := tls.X509KeyPair(pem.Certificate, pem.PrivateKey)
243 require.NoError(tb, err)
244 server.TLSConfig = &tls.Config{
245 Certificates: []tls.Certificate{tlsCertificate},
246 }
247
248 m.clientTLSConfig = &tls.Config{
249 InsecureSkipVerify: true,
250 }
251 }
252 go func() {
253 if cfg.WithTLS {
254 _ = server.ServeTLS(ln, "", "")
255 } else {
256 _ = server.Serve(ln)
257 }
258 }()
259 m.server = server
260 return m
261 }