GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

cloudflare/pint

Public

mirrored from https://github.com/cloudflare/pintAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
main

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

pint/cmd/pint

cmd/pint/bench_test.go

301lines · modecode

RawDownload
Latest commit unavailable.
1package main
2
3import (
4 "fmt"
5 "log/slog"
6 "net/http"
7 "net/http/httptest"
8 "os"
9 "testing"
10
11 "github.com/prometheus/client_golang/prometheus"
12 "github.com/stretchr/testify/require"
13
14 "github.com/cloudflare/pint/internal/checks"
15 "github.com/cloudflare/pint/internal/config"
16 "github.com/cloudflare/pint/internal/discovery"
17 "github.com/cloudflare/pint/internal/git"
18 "github.com/cloudflare/pint/internal/log"
19 "github.com/cloudflare/pint/internal/parser"
20 "github.com/cloudflare/pint/internal/promapi"
21)
22
23func BenchmarkGlobFinder(b *testing.B) {
24 log.Setup(slog.LevelError, true)
25
26 finder := discovery.NewGlobFinder(
27 []string{"bench/rules"},
28 git.NewPathFilter(nil, nil, nil),
29 parser.DefaultOptions,
30 nil,
31 )
32
33 b.ResetTimer()
34 for b.Loop() {
35 _, _ = finder.Find()
36 }
37}
38
39func BenchmarkGitFinder(b *testing.B) {
40 log.Setup(slog.LevelError, true)
41
42 tmp := b.TempDir()
43 require.NoError(b, os.CopyFS(tmp, os.DirFS("bench")))
44 b.Chdir(tmp)
45
46 b.Setenv("GIT_AUTHOR_NAME", "pint")
47 b.Setenv("GIT_AUTHOR_EMAIL", "pint@example.com")
48 b.Setenv("GIT_COMMITTER_NAME", "pint")
49 b.Setenv("GIT_COMMITTER_EMAIL", "pint")
50
51 ctx := b.Context()
52
53 _, err := git.RunGit(ctx, "init", "--initial-branch=main", ".")
54 require.NoError(b, err, "git init")
55
56 _, err = git.RunGit(ctx, "add", "Makefile", "README.md")
57 require.NoError(b, err, "git add")
58 _, err = git.RunGit(ctx, "commit", "-am", "commit")
59 require.NoError(b, err, "git commit")
60
61 _, err = git.RunGit(ctx, "checkout", "-b", "v2")
62 require.NoError(b, err, "git checkout v2")
63
64 _, err = git.RunGit(ctx, "add", ".")
65 require.NoError(b, err, "git add")
66
67 _, err = git.RunGit(ctx, "commit", "-am", "commit")
68 require.NoError(b, err, "git commit")
69
70 finder := discovery.NewGitBranchFinder(
71 git.RunGit,
72 git.NewPathFilter(nil, nil, nil),
73 "main",
74 50,
75 parser.DefaultOptions,
76 nil,
77 )
78
79 b.ResetTimer()
80 for b.Loop() {
81 _, _ = finder.Find(ctx, nil)
82 }
83}
84
85func benchmarkConfig(uri string) []byte {
86 return fmt.Appendf(nil, `prometheus "prom" {
87 uri = "%s"
88 timeout = "30s"
89 uptime = "prometheus_ready"
90 concurrency = 10
91 rateLimit = 5000
92}
93
94rule {
95 alerts {
96 range = "1h"
97 step = "1m"
98 resolve = "5m"
99 minCount = 50
100 }
101}
102rule {
103 reject "https?://.+" {
104 label_keys = true
105 label_values = true
106 }
107}
108
109rule {
110 match {
111 kind = "alerting"
112 }
113 annotation "summary" {
114 severity = "bug"
115 required = true
116 }
117 annotation "dashboard" {
118 severity = "warning"
119 value = "https://(.+)"
120 }
121
122 label "priority" {
123 severity = "bug"
124 value = "(1|2|3|4)"
125 required = true
126 }
127
128 label "component" {
129 severity = "bug"
130 required = true
131 }
132
133 annotation "link" {
134 severity = "warning"
135 value = "https://(.+)"
136 }
137}
138
139rule {
140 match {
141 kind = "recording"
142 }
143 aggregate ".+" {
144 severity = "bug"
145 keep = ["job"]
146 }
147}
148
149rule {
150 cost {
151 maxSeries = 2000
152 maxPeakSamples = 200000
153 maxEvaluationDuration = "30s"
154 severity = "warning"
155 }
156}
157`, uri)
158}
159
160func BenchmarkCheck(b *testing.B) {
161 log.Setup(slog.LevelError, true)
162
163 finder := discovery.NewGlobFinder(
164 []string{"bench/rules"},
165 git.NewPathFilter(nil, nil, nil),
166 parser.DefaultOptions,
167 nil,
168 )
169 entries, err := finder.Find()
170 if err != nil {
171 b.Errorf("Find() error: %s", err)
172 b.FailNow()
173 }
174
175 srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
176 switch r.URL.Path {
177 case promapi.APIPathConfig:
178 w.WriteHeader(http.StatusOK)
179 w.Header().Set("Content-Type", "application/json")
180 _, _ = w.Write([]byte(`{"status":"success","data":{"yaml":"global:\n scrape_interval: 30s\n"}}`))
181 case promapi.APIPathFlags:
182 w.WriteHeader(http.StatusOK)
183 w.Header().Set("Content-Type", "application/json")
184 _, _ = w.Write([]byte(`{"status":"success","data":{"storage.tsdb.retention.time": "1d"}}`))
185 case promapi.APIPathMetadata:
186 w.WriteHeader(http.StatusOK)
187 w.Header().Set("Content-Type", "application/json")
188 _, _ = w.Write([]byte(`{"status":"success","data":{}}`))
189 case promapi.APIPathQuery:
190 w.WriteHeader(http.StatusOK)
191 w.Header().Set("Content-Type", "application/json")
192 _, _ = w.Write([]byte(`{"status":"success","data":{"resultType":"vector","result":[]}}`))
193 case promapi.APIPathQueryRange:
194 w.WriteHeader(http.StatusOK)
195 w.Header().Set("Content-Type", "application/json")
196 _, _ = w.Write([]byte(`{"status":"success","data":{"resultType":"matrix","result":[]}}`))
197 default:
198 w.WriteHeader(http.StatusNotFound)
199 _, _ = w.Write([]byte(`Not found`))
200 }
201 }))
202 b.Cleanup(srv.Close)
203
204 tmp := b.TempDir()
205 content := benchmarkConfig(srv.URL)
206 require.NoError(b, os.WriteFile(tmp+"/.pint.hcl", content, 0o644))
207
208 cfg, _, err := config.Load(tmp+"/.pint.hcl", false)
209 require.NoError(b, err)
210
211 gen := config.NewPrometheusGenerator(cfg, prometheus.NewRegistry())
212 gen.GenerateStatic()
213
214 type checkEntry struct {
215 check checks.RuleChecker
216 entry *discovery.Entry
217 }
218 byReporter := map[string][]checkEntry{}
219 for _, entry := range entries {
220 for _, check := range cfg.GetChecksForEntry(b.Context(), gen, entry) {
221 name := check.Reporter()
222 byReporter[name] = append(byReporter[name], checkEntry{
223 check: check,
224 entry: entry,
225 })
226 }
227 }
228
229 for reporter, items := range byReporter {
230 b.Run(reporter, func(b *testing.B) {
231 // Warm up the cache, without this first run is super expensive
232 // compared to all other runs, which creates huge variance in benchmark output.
233 for _, item := range items {
234 item.check.Check(b.Context(), item.entry, entries)
235 }
236 for b.Loop() {
237 for _, item := range items {
238 item.check.Check(b.Context(), item.entry, entries)
239 }
240 }
241 })
242 }
243}
244
245func BenchmarkRuleIsIdentical(b *testing.B) {
246 log.Setup(slog.LevelError, true)
247
248 finder := discovery.NewGlobFinder(
249 []string{"bench/rules"},
250 git.NewPathFilter(nil, nil, nil),
251 parser.DefaultOptions,
252 nil,
253 )
254 entries, err := finder.Find()
255 if err != nil {
256 b.Errorf("Find() error: %s", err)
257 b.FailNow()
258 }
259
260 b.ResetTimer()
261 for b.Loop() {
262 for _, e := range entries {
263 for _, o := range entries {
264 e.Rule.IsIdentical(o.Rule)
265 }
266 }
267 }
268}
269
270func BenchmarkGetChecksForEntry(b *testing.B) {
271 log.Setup(slog.LevelError, true)
272
273 finder := discovery.NewGlobFinder(
274 []string{"bench/rules"},
275 git.NewPathFilter(nil, nil, nil),
276 parser.DefaultOptions,
277 nil,
278 )
279 entries, err := finder.Find()
280 if err != nil {
281 b.Errorf("Find() error: %s", err)
282 b.FailNow()
283 }
284
285 tmp := b.TempDir()
286 content := benchmarkConfig("http://localhost:9090")
287 require.NoError(b, os.WriteFile(tmp+"/.pint.hcl", content, 0o644))
288
289 cfg, _, err := config.Load(tmp+"/.pint.hcl", false)
290 require.NoError(b, err)
291
292 gen := config.NewPrometheusGenerator(cfg, prometheus.NewRegistry())
293 gen.GenerateStatic()
294
295 b.ResetTimer()
296 for b.Loop() {
297 for _, entry := range entries {
298 cfg.GetChecksForEntry(b.Context(), gen, entry)
299 }
300 }
301}
302