this repo has no description
add new-style identity metrics to redisdir
+82
-26
+18
-26
atproto/identity/redisdir/metrics.go
+18
-26
atproto/identity/redisdir/metrics.go
···
5
5
"github.com/prometheus/client_golang/prometheus/promauto"
6
6
)
7
7
8
-
var handleCacheHits = promauto.NewCounter(prometheus.CounterOpts{
9
-
Name: "atproto_redis_directory_handle_cache_hits",
10
-
Help: "Number of cache hits for ATProto handle lookups",
11
-
})
12
-
13
-
var handleCacheMisses = promauto.NewCounter(prometheus.CounterOpts{
14
-
Name: "atproto_redis_directory_handle_cache_misses",
15
-
Help: "Number of cache misses for ATProto handle lookups",
16
-
})
17
-
18
-
var identityCacheHits = promauto.NewCounter(prometheus.CounterOpts{
19
-
Name: "atproto_redis_directory_identity_cache_hits",
20
-
Help: "Number of cache hits for ATProto identity lookups",
21
-
})
8
+
var handleResolution = promauto.NewCounterVec(prometheus.CounterOpts{
9
+
Name: "atproto_identity_resolve_handle",
10
+
Help: "ATProto handle resolutions",
11
+
}, []string{"directory", "status"})
22
12
23
-
var identityCacheMisses = promauto.NewCounter(prometheus.CounterOpts{
24
-
Name: "atproto_redis_directory_identity_cache_misses",
25
-
Help: "Number of cache misses for ATProto identity lookups",
26
-
})
13
+
var handleResolutionDuration = promauto.NewHistogramVec(prometheus.HistogramOpts{
14
+
Name: "atproto_identity_resolve_handle_duration",
15
+
Help: "Time to resolve a handle",
16
+
Buckets: prometheus.ExponentialBucketsRange(0.001, 2, 15),
17
+
}, []string{"directory", "status"})
27
18
28
-
var identityRequestsCoalesced = promauto.NewCounter(prometheus.CounterOpts{
29
-
Name: "atproto_redis_directory_identity_requests_coalesced",
30
-
Help: "Number of identity requests coalesced",
31
-
})
19
+
var didResolution = promauto.NewCounterVec(prometheus.CounterOpts{
20
+
Name: "atproto_identity_resolve_did",
21
+
Help: "ATProto DID resolutions",
22
+
}, []string{"directory", "status"})
32
23
33
-
var handleRequestsCoalesced = promauto.NewCounter(prometheus.CounterOpts{
34
-
Name: "atproto_redis_directory_handle_requests_coalesced",
35
-
Help: "Number of handle requests coalesced",
36
-
})
24
+
var didResolutionDuration = promauto.NewHistogramVec(prometheus.HistogramOpts{
25
+
Name: "atproto_identity_resolve_did_duration",
26
+
Help: "Time to resolve a DID",
27
+
Buckets: prometheus.ExponentialBucketsRange(0.001, 2, 15),
28
+
}, []string{"directory", "status"})
+42
atproto/identity/redisdir/metrics_legacy.go
+42
atproto/identity/redisdir/metrics_legacy.go
···
1
+
package redisdir
2
+
3
+
import (
4
+
"github.com/prometheus/client_golang/prometheus"
5
+
"github.com/prometheus/client_golang/prometheus/promauto"
6
+
)
7
+
8
+
// DEPRECATED
9
+
var handleCacheHits = promauto.NewCounter(prometheus.CounterOpts{
10
+
Name: "atproto_redis_directory_handle_cache_hits",
11
+
Help: "Number of cache hits for ATProto handle lookups",
12
+
})
13
+
14
+
// DEPRECATED
15
+
var handleCacheMisses = promauto.NewCounter(prometheus.CounterOpts{
16
+
Name: "atproto_redis_directory_handle_cache_misses",
17
+
Help: "Number of cache misses for ATProto handle lookups",
18
+
})
19
+
20
+
// DEPRECATED
21
+
var identityCacheHits = promauto.NewCounter(prometheus.CounterOpts{
22
+
Name: "atproto_redis_directory_identity_cache_hits",
23
+
Help: "Number of cache hits for ATProto identity lookups",
24
+
})
25
+
26
+
// DEPRECATED
27
+
var identityCacheMisses = promauto.NewCounter(prometheus.CounterOpts{
28
+
Name: "atproto_redis_directory_identity_cache_misses",
29
+
Help: "Number of cache misses for ATProto identity lookups",
30
+
})
31
+
32
+
// DEPRECATED
33
+
var identityRequestsCoalesced = promauto.NewCounter(prometheus.CounterOpts{
34
+
Name: "atproto_redis_directory_identity_requests_coalesced",
35
+
Help: "Number of identity requests coalesced",
36
+
})
37
+
38
+
// DEPRECATED
39
+
var handleRequestsCoalesced = promauto.NewCounter(prometheus.CounterOpts{
40
+
Name: "atproto_redis_directory_handle_requests_coalesced",
41
+
Help: "Number of handle requests coalesced",
42
+
})
+22
atproto/identity/redisdir/redis_directory.go
+22
atproto/identity/redisdir/redis_directory.go
···
155
155
}
156
156
157
157
func (d *RedisDirectory) ResolveHandle(ctx context.Context, h syntax.Handle) (syntax.DID, error) {
158
+
start := time.Now()
158
159
if h.IsInvalidHandle() {
159
160
return "", fmt.Errorf("can not resolve handle: %w", identity.ErrInvalidHandle)
160
161
}
161
162
var entry handleEntry
162
163
err := d.handleCache.Get(ctx, redisDirPrefix+h.String(), &entry)
163
164
if err != nil && err != cache.ErrCacheMiss {
165
+
handleResolution.WithLabelValues("redisdir", "error").Inc()
166
+
handleResolutionDuration.WithLabelValues("redisdir", "error").Observe(time.Since(start).Seconds())
164
167
return "", fmt.Errorf("identity cache read failed: %w", err)
165
168
}
166
169
if err == nil && !d.isHandleStale(&entry) { // if no error...
167
170
handleCacheHits.Inc()
171
+
handleResolution.WithLabelValues("redisdir", "cached").Inc()
172
+
handleResolutionDuration.WithLabelValues("redisdir", "cached").Observe(time.Since(start).Seconds())
168
173
if entry.Err != nil {
169
174
return "", entry.Err
170
175
} else if entry.DID != nil {
···
180
185
val, loaded := d.handleLookupChans.LoadOrStore(h.String(), res)
181
186
if loaded {
182
187
handleRequestsCoalesced.Inc()
188
+
handleResolution.WithLabelValues("redisdir", "coalesced").Inc()
189
+
handleResolutionDuration.WithLabelValues("redisdir", "coalesced").Observe(time.Since(start).Seconds())
183
190
// Wait for the result from the pending request
184
191
select {
185
192
case <-val.(chan struct{}):
···
212
219
close(res)
213
220
214
221
if newEntry.Err != nil {
222
+
handleResolution.WithLabelValues("redisdir", "error").Inc()
223
+
handleResolutionDuration.WithLabelValues("redisdir", "error").Observe(time.Since(start).Seconds())
215
224
return "", newEntry.Err
216
225
}
217
226
if newEntry.DID != nil {
227
+
handleResolution.WithLabelValues("redisdir", "success").Inc()
228
+
handleResolutionDuration.WithLabelValues("redisdir", "success").Observe(time.Since(start).Seconds())
218
229
return *newEntry.DID, nil
219
230
}
220
231
return "", errors.New("unexpected control-flow error")
···
267
278
}
268
279
269
280
func (d *RedisDirectory) LookupDIDWithCacheState(ctx context.Context, did syntax.DID) (*identity.Identity, bool, error) {
281
+
start := time.Now()
270
282
var entry identityEntry
271
283
err := d.identityCache.Get(ctx, redisDirPrefix+did.String(), &entry)
272
284
if err != nil && err != cache.ErrCacheMiss {
285
+
didResolution.WithLabelValues("redisdir", "error").Inc()
286
+
didResolutionDuration.WithLabelValues("redisdir", "error").Observe(time.Since(start).Seconds())
273
287
return nil, false, fmt.Errorf("identity cache read failed: %w", err)
274
288
}
275
289
if err == nil && !d.isIdentityStale(&entry) { // if no error...
276
290
identityCacheHits.Inc()
291
+
didResolution.WithLabelValues("redisdir", "cached").Inc()
292
+
didResolutionDuration.WithLabelValues("redisdir", "cached").Observe(time.Since(start).Seconds())
277
293
return entry.Identity, true, entry.Err
278
294
}
279
295
identityCacheMisses.Inc()
···
283
299
val, loaded := d.didLookupChans.LoadOrStore(did.String(), res)
284
300
if loaded {
285
301
identityRequestsCoalesced.Inc()
302
+
didResolution.WithLabelValues("redisdir", "coalesced").Inc()
303
+
didResolutionDuration.WithLabelValues("redisdir", "coalesced").Observe(time.Since(start).Seconds())
286
304
// Wait for the result from the pending request
287
305
select {
288
306
case <-val.(chan struct{}):
···
309
327
close(res)
310
328
311
329
if newEntry.Err != nil {
330
+
didResolution.WithLabelValues("redisdir", "error").Inc()
331
+
didResolutionDuration.WithLabelValues("redisdir", "error").Observe(time.Since(start).Seconds())
312
332
return nil, false, newEntry.Err
313
333
}
314
334
if newEntry.Identity != nil {
335
+
didResolution.WithLabelValues("redisdir", "success").Inc()
336
+
didResolutionDuration.WithLabelValues("redisdir", "success").Observe(time.Since(start).Seconds())
315
337
return newEntry.Identity, false, nil
316
338
}
317
339
return nil, false, errors.New("unexpected control-flow error")