GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

cloudflare/pint

Public

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

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
v0.82.1

Branches

Tags

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

Clone

HTTPS

Download ZIP

pint/cmd/pint

cmd/pint/bench_test.go

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