ebpf_exporter

1
package decoder
2

3
import (
4
	"fmt"
5
	"sync"
6
	"testing"
7

8
	"github.com/cloudflare/ebpf_exporter/v2/config"
9
)
10

11
func TestDecodeLabels(t *testing.T) {
12
	cases := []struct {
13
		in     []byte
14
		labels []config.Label
15
		out    []string
16
		err    bool
17
	}{
18
		{
19
			in: append([]byte{0x8, 0x0, 0x0, 0x0}, zeroPaddedString("potatoes", 16)...),
20
			labels: []config.Label{
21
				{
22
					Name: "number",
23
					Size: 4,
24
					Decoders: []config.Decoder{
25
						{
26
							Name: "uint",
27
						},
28
					},
29
				},
30
			},
31
			out: []string{"8"},
32
			err: true, // not all labels are decoded
33
		},
34
		{
35
			in: append([]byte{0x8, 0x0, 0x0, 0x0}, zeroPaddedString("bananas", 32)...),
36
			labels: []config.Label{
37
				{
38
					Name: "number",
39
					Size: 4,
40
					Decoders: []config.Decoder{
41
						{
42
							Name: "uint",
43
						},
44
					},
45
				},
46
				{
47
					Name: "fruit",
48
					Size: 32,
49
					Decoders: []config.Decoder{
50
						{
51
							Name: "string",
52
						},
53
					},
54
				},
55
			},
56
			out: []string{"8", "bananas"},
57
			err: false,
58
		},
59
		{
60
			in: append([]byte{0x8, 0x0, 0x0, 0x0}, zeroPaddedString("bananas", 32)...),
61
			labels: []config.Label{
62
				{
63
					Name: "number",
64
					Size: 4,
65
					Decoders: []config.Decoder{
66
						{
67
							Name: "uint",
68
						},
69
					},
70
				},
71
				{
72
					Name: "fruit",
73
					Size: 32,
74
					Decoders: []config.Decoder{
75
						{
76
							Name: "string",
77
						},
78
						{
79
							Name: "regexp",
80
							Regexps: []string{
81
								"^bananas$",
82
								"$is-banana-even-fruit$",
83
							},
84
						},
85
					},
86
				},
87
			},
88
			out: []string{"8", "bananas"},
89
			err: false,
90
		},
91
		{
92
			in: append([]byte{0x8, 0x0, 0x0, 0x0}, zeroPaddedString("bananas", 32)...),
93
			labels: []config.Label{
94
				{
95
					Name: "number",
96
					Size: 4,
97
					Decoders: []config.Decoder{
98
						{
99
							Name: "uint",
100
						},
101
					},
102
				},
103
				{
104
					Name: "fruit",
105
					Size: 32,
106
					Decoders: []config.Decoder{
107
						{
108
							Name: "string",
109
						},
110
						{
111
							Name: "regexp",
112
							Regexps: []string{
113
								"^tomato$",
114
							},
115
						},
116
					},
117
				},
118
			},
119
			out: []string{"8", "bananas"},
120
			err: true, // this label should be skipped, only tomatoes allowed
121
		},
122
	}
123

124
	for i, c := range cases {
125
		s, err := NewSet()
126
		if err != nil {
127
			t.Fatal(err)
128
		}
129

130
		out, err := s.DecodeLabels(c.in, fmt.Sprintf("test:%d", i), c.labels)
131
		if c.err {
132
			if err == nil {
133
				t.Errorf("Expected error for input %#v and labels %#v, but did not receive it", c.in, c.labels)
134
			}
135

136
			continue
137
		}
138

139
		if err != nil {
140
			t.Errorf("Error decoding %#v with labels set to %#v: %s", c.in, c.labels, err)
141
		}
142

143
		if len(c.out) != len(out) {
144
			t.Errorf("Expected %d outputs (%v), received %d (%v)", len(c.out), c.out, len(out), out)
145
		}
146

147
		for i := 0; i < len(c.out) && i < len(out); i++ {
148
			if c.out[i] != out[i] {
149
				t.Errorf("Output label %d for input %#v is wrong: expected %s, but received %s", i, c.in, c.out[i], out[i])
150
			}
151
		}
152
	}
153
}
154

155
func TestDecoderSetConcurrency(t *testing.T) {
156
	in := append([]byte{0x8, 0x0, 0x0, 0x0}, zeroPaddedString("bananas", 32)...)
157

158
	labels := []config.Label{
159
		{
160
			Name: "number",
161
			Size: 4,
162
			Decoders: []config.Decoder{
163
				{
164
					Name: "uint",
165
				},
166
			},
167
		},
168
		{
169
			Name: "fruit",
170
			Size: 32,
171
			Decoders: []config.Decoder{
172
				{
173
					Name: "string",
174
				},
175
				{
176
					Name: "regexp",
177
					Regexps: []string{
178
						"^bananas$",
179
						"$is-banana-even-fruit$",
180
					},
181
				},
182
			},
183
		},
184
	}
185

186
	s, err := NewSet()
187
	if err != nil {
188
		t.Fatal(err)
189
	}
190

191
	count := 1000
192

193
	wg := sync.WaitGroup{}
194
	wg.Add(count)
195

196
	for i := 0; i < count; i++ {
197
		go func() {
198
			defer wg.Done()
199

200
			_, err := s.DecodeLabels(in, "concurrency", labels)
201
			if err != nil {
202
				t.Error(err)
203
			}
204
		}()
205
	}
206

207
	wg.Wait()
208
}
209

210
func TestDecoderSetCache(t *testing.T) {
211
	in := []byte{0xba, 0xbe, 0xba, 0xbe, 0xde, 0xad, 0xbe, 0xef}
212

213
	one := []config.Label{
214
		{
215
			Name: "single_u64",
216
			Size: 8,
217
			Decoders: []config.Decoder{
218
				{
219
					Name: "uint",
220
				},
221
			},
222
		},
223
	}
224

225
	two := []config.Label{
226
		{
227
			Name: "u32_one",
228
			Size: 4,
229
			Decoders: []config.Decoder{
230
				{
231
					Name: "uint",
232
				},
233
			},
234
		},
235
		{
236
			Name: "u32_two",
237
			Size: 4,
238
			Decoders: []config.Decoder{
239
				{
240
					Name: "uint",
241
				},
242
			},
243
		},
244
	}
245

246
	s, err := NewSet()
247
	if err != nil {
248
		t.Fatal(err)
249
	}
250

251
	single, err := s.DecodeLabels(in, "one", one)
252
	if err != nil {
253
		t.Fatal(err)
254
	}
255

256
	if len(single) != 1 {
257
		t.Errorf("Expected one u64 from %#v, got %#v", one, single)
258
	}
259

260
	double, err := s.DecodeLabels(in, "two", two)
261
	if err != nil {
262
		t.Error(err)
263
	}
264

265
	if len(double) != 2 {
266
		t.Errorf("Expected two u32 from %#v, got %#v", two, double)
267
	}
268
}
269

270
func BenchmarkCache(b *testing.B) {
271
	in := []byte{
272
		0x8, 0xab, 0xce, 0xef,
273
		0xde, 0xad,
274
		0xbe, 0xef,
275
		0x8, 0xab, 0xce, 0xef, 0x8, 0xab, 0xce, 0xef,
276
	}
277

278
	labels := []config.Label{
279
		{
280
			Name: "number1",
281
			Size: 4,
282
			Decoders: []config.Decoder{
283
				{
284
					Name: "uint",
285
				},
286
			},
287
		},
288
		{
289
			Name: "number2",
290
			Size: 2,
291
			Decoders: []config.Decoder{
292
				{
293
					Name: "uint",
294
				},
295
			},
296
		},
297
		{
298
			Name: "number3",
299
			Size: 2,
300
			Decoders: []config.Decoder{
301
				{
302
					Name: "uint",
303
				},
304
			},
305
		},
306
		{
307
			Name: "number4",
308
			Size: 8,
309
			Decoders: []config.Decoder{
310
				{
311
					Name: "uint",
312
				},
313
			},
314
		},
315
	}
316

317
	s, err := NewSet()
318
	if err != nil {
319
		b.Fatal(err)
320
	}
321

322
	b.Run("direct", func(b *testing.B) {
323
		for i := 0; i < b.N; i++ {
324
			_, err := s.decodeLabels(in, labels)
325
			if err != nil {
326
				b.Fatal(err)
327
			}
328
		}
329
	})
330

331
	b.Run("cached", func(b *testing.B) {
332
		for i := 0; i < b.N; i++ {
333
			_, err := s.DecodeLabels(in, "test", labels)
334
			if err != nil {
335
				b.Fatal(err)
336
			}
337
		}
338
	})
339
}
340

341
func zeroPaddedString(in string, size int) []byte {
342
	if len(in) > size {
343
		panic(fmt.Sprintf("string %q is longer than requested size %d", in, size))
344
	}
345

346
	return append([]byte(in), make([]byte, size-len(in))...)
347
}
348