melosh/mal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: replace package-level traceEnabled with per-client field

Browse Source
This commit is contained in:
mkelvers
2026-06-16 01:01:54 +02:00
committed by Milas Holsting
parent 31a8da10b4
commit ec10fa56b4
1 changed files with 35 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
integrations/jikan/client.go
View File

@@ -18,16 +18,15 @@ import (
"golang.org/x/sync/singleflight" "golang.org/x/sync/singleflight"
) )
var traceEnabled bool
type Client struct { type Client struct {
baseURL string baseURL string
db db.Querier db db.Querier
retrySignal chan struct{} // signals retry worker to process queued retries retrySignal chan struct{} // signals retry worker to process queued retries
sf singleflight.Group sf singleflight.Group
refreshSem chan struct{} refreshSem chan struct{}
cache *jcache.Store cache *jcache.Store
fetcher *jtransport.Client fetcher *jtransport.Client
traceEnabled bool
// Random anime pool for DDoS-proof truly random "Surprise Me" // Random anime pool for DDoS-proof truly random "Surprise Me"
randomPool []Anime randomPool []Anime
@@ -40,22 +39,24 @@ const jikanSlowLogThreshold = 750 * time.Millisecond
type APIError = jtransport.APIError type APIError = jtransport.APIError
func NewClient(cfg config.Config, queries *db.Queries, metrics *observability.Metrics) *Client { func NewClient(cfg config.Config, queries *db.Queries, metrics *observability.Metrics) *Client {
traceEnabled = cfg.JikanTrace
limiter := rate.NewLimiter(400 * time.Millisecond) limiter := rate.NewLimiter(400 * time.Millisecond)
return &Client{ client := &Client{
baseURL: "https://api.jikan.moe/v4", baseURL: "https://api.jikan.moe/v4",
db: queries, db: queries,
retrySignal: make(chan struct{}, 1), retrySignal: make(chan struct{}, 1),
refreshSem: make(chan struct{}, 4), refreshSem: make(chan struct{}, 4),
cache: jcache.NewStore(queries, metrics), cache: jcache.NewStore(queries, metrics),
fetcher: jtransport.NewClient(jtransport.Config{ traceEnabled: cfg.JikanTrace,
HTTPClient: jtransport.NewHTTPClient(), randomPool: make([]Anime, 0),
Limiter: limiter,
Metrics: metrics,
TraceEnabled: jikanTraceEnabled,
}),
randomPool: make([]Anime, 0),
} }
client.fetcher = jtransport.NewClient(jtransport.Config{
HTTPClient: jtransport.NewHTTPClient(),
Limiter: limiter,
Metrics: metrics,
TraceEnabled: client.jikanTraceEnabled,
})
return client
} }
// IsRetryableError returns true if the error should trigger a retry. // IsRetryableError returns true if the error should trigger a retry.
@@ -63,12 +64,12 @@ func IsRetryableError(err error) bool {
return jtransport.IsRetryableError(err) return jtransport.IsRetryableError(err)
} }
func jikanTraceEnabled() bool { func (c *Client) jikanTraceEnabled() bool {
return traceEnabled return c.traceEnabled
} }
func shouldSkipJikanCacheLog(source string, duration time.Duration, err error) bool { func (c *Client) shouldSkipJikanCacheLog(source string, duration time.Duration, err error) bool {
if jikanTraceEnabled() || err != nil { if c.jikanTraceEnabled() || err != nil {
return false return false
} }
@@ -96,9 +97,9 @@ func jikanCacheLogLevel(source string, err error) observability.LogLevel {
return observability.LogLevelInfo return observability.LogLevelInfo
} }
func logJikanCache(cacheKey string, source string, startedAt time.Time, err error) { func (c *Client) logJikanCache(cacheKey string, source string, startedAt time.Time, err error) {
duration := time.Since(startedAt) duration := time.Since(startedAt)
if shouldSkipJikanCacheLog(source, duration, err) { if c.shouldSkipJikanCacheLog(source, duration, err) {
return return
} }
@@ -275,26 +276,26 @@ func (c *Client) getWithCache(ctx context.Context, cacheKey string, ttl time.Dur
startedAt := time.Now() startedAt := time.Now()
if c.getCache(ctx, cacheKey, out) { if c.getCache(ctx, cacheKey, out) {
if !isEmptyResult(out) { if !isEmptyResult(out) {
logJikanCache(cacheKey, "fresh", startedAt, nil) c.logJikanCache(cacheKey, "fresh", startedAt, nil)
return nil return nil
} }
} }
if c.getStaleCache(ctx, cacheKey, out) && !isEmptyResult(out) { if c.getStaleCache(ctx, cacheKey, out) && !isEmptyResult(out) {
logJikanCache(cacheKey, "stale", startedAt, nil) c.logJikanCache(cacheKey, "stale", startedAt, nil)
c.refreshWithCacheAsync(cacheKey, ttl, url, out) c.refreshWithCacheAsync(cacheKey, ttl, url, out)
return nil return nil
} }
if err := c.refreshWithCache(ctx, cacheKey, ttl, url, out); err != nil { if err := c.refreshWithCache(ctx, cacheKey, ttl, url, out); err != nil {
if c.getStaleCache(ctx, cacheKey, out) && !isEmptyResult(out) { if c.getStaleCache(ctx, cacheKey, out) && !isEmptyResult(out) {
logJikanCache(cacheKey, "stale_after_error", startedAt, err) c.logJikanCache(cacheKey, "stale_after_error", startedAt, err)
return nil return nil
} }
logJikanCache(cacheKey, "miss", startedAt, err) c.logJikanCache(cacheKey, "miss", startedAt, err)
return err return err
} }
logJikanCache(cacheKey, "refresh", startedAt, nil) c.logJikanCache(cacheKey, "refresh", startedAt, nil)
return nil return nil
} }