mirror of
https://github.com/navidrome/navidrome.git
synced 2026-11-19 08:38:50 +01:00
errchkjson flags json.Marshal/MarshalIndent/Encoder.Encode calls whose error is discarded.
Fixed all 27 sites by hand: errors are returned where the caller already returns one, logged
in HTTP handlers and string-returning helpers, and asserted in tests.
check-error-free-encoding stays off so every encode error is handled, even for safe types.
report-no-exported is on, to catch structs that would silently encode as {}.
156 lines
4.6 KiB
Go
156 lines
4.6 KiB
Go
package artwork
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"io"
|
|
"slices"
|
|
"sync"
|
|
|
|
"github.com/navidrome/navidrome/log"
|
|
"github.com/navidrome/navidrome/utils/str"
|
|
)
|
|
|
|
// Outcome is what the priority chain observed for one candidate; the CLI renders and branches on these.
|
|
type Outcome string
|
|
|
|
const (
|
|
OutcomeHit Outcome = "hit"
|
|
OutcomeMiss Outcome = "miss"
|
|
OutcomeUnreadable Outcome = "unreadable"
|
|
OutcomeSkipped Outcome = "skipped"
|
|
OutcomeError Outcome = "error"
|
|
)
|
|
|
|
const (
|
|
// externalCandidate labels the external tier itself, for the cases that never reach an agent.
|
|
externalCandidate = "external"
|
|
// ExternalPrefix qualifies a candidate or a stored source with the agent that produced it.
|
|
ExternalPrefix = externalCandidate + ":"
|
|
)
|
|
|
|
// TraceStep is one candidate the priority chain considered.
|
|
type TraceStep struct {
|
|
Candidate string
|
|
Outcome Outcome
|
|
Detail string
|
|
}
|
|
|
|
// ChainTrace collects the walk of a single resolution: the worker attaches one per queue
|
|
// item so it can be stored, and the CLI attaches one per explain.
|
|
type ChainTrace struct {
|
|
mu sync.Mutex
|
|
steps []TraceStep
|
|
}
|
|
|
|
func (t *ChainTrace) add(step TraceStep) {
|
|
if t == nil {
|
|
return
|
|
}
|
|
t.mu.Lock()
|
|
defer t.mu.Unlock()
|
|
t.steps = append(t.steps, step)
|
|
}
|
|
|
|
func (t *ChainTrace) Steps() []TraceStep {
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
t.mu.Lock()
|
|
defer t.mu.Unlock()
|
|
return slices.Clone(t.steps)
|
|
}
|
|
|
|
// maxTraceDetail bounds a stored Detail, which on the failure paths is an error string of
|
|
// unknown length. Past ~1kB a row spills to an overflow page, slowing every scan of the table.
|
|
const maxTraceDetail = 200
|
|
|
|
// storedStep is the persisted shape of a TraceStep. The keys are single letters because a trace
|
|
// is written for every item, and the encoded length is repeated across the whole library.
|
|
type storedStep struct {
|
|
C string `json:"c"`
|
|
O Outcome `json:"o"`
|
|
D string `json:"d,omitempty"`
|
|
}
|
|
|
|
// encode serializes the trace for storage, without the copy Steps would make for a caller
|
|
// that only wants to write it.
|
|
func (t *ChainTrace) encode(sourcePath string) string {
|
|
if t == nil {
|
|
return encodeSteps(nil, sourcePath)
|
|
}
|
|
t.mu.Lock()
|
|
defer t.mu.Unlock()
|
|
return encodeSteps(t.steps, sourcePath)
|
|
}
|
|
|
|
// encodeSteps writes the stored form. A hit's Detail is the winning source's path, which the
|
|
// same row already stores as source_path, so it is dropped and DecodeTrace puts it back.
|
|
func encodeSteps(steps []TraceStep, sourcePath string) string {
|
|
out := make([]storedStep, 0, len(steps))
|
|
for _, s := range steps {
|
|
d := s.Detail
|
|
if s.Outcome == OutcomeHit && d == sourcePath {
|
|
d = ""
|
|
}
|
|
out = append(out, storedStep{C: s.Candidate, O: s.Outcome, D: str.TruncateRunes(d, maxTraceDetail, "...")})
|
|
}
|
|
b, err := json.Marshal(out)
|
|
if err != nil {
|
|
log.Error("Artwork: Could not encode resolution trace", err)
|
|
}
|
|
return string(b)
|
|
}
|
|
|
|
// DecodeTrace reverses the stored form. A trace that will not parse is reported as no trace at all,
|
|
// since a diagnostic command must not fail on a bad row.
|
|
func DecodeTrace(encoded, sourcePath string) []TraceStep {
|
|
if encoded == "" {
|
|
return nil
|
|
}
|
|
var stored []storedStep
|
|
if err := json.Unmarshal([]byte(encoded), &stored); err != nil {
|
|
return nil
|
|
}
|
|
steps := make([]TraceStep, 0, len(stored))
|
|
for _, s := range stored {
|
|
d := s.D
|
|
if d == "" && s.O == OutcomeHit {
|
|
d = sourcePath
|
|
}
|
|
steps = append(steps, TraceStep{Candidate: s.C, Outcome: s.O, Detail: d})
|
|
}
|
|
return steps
|
|
}
|
|
|
|
type traceCtxKey struct{}
|
|
|
|
func withTrace(ctx context.Context, t *ChainTrace) context.Context {
|
|
return context.WithValue(ctx, traceCtxKey{}, t)
|
|
}
|
|
|
|
func traceFrom(ctx context.Context) *ChainTrace {
|
|
t, _ := ctx.Value(traceCtxKey{}).(*ChainTrace)
|
|
return t
|
|
}
|
|
|
|
// recordAgent files what one external agent answered. The agent loops call this rather than a
|
|
// gate wrapper, because only they hold the context that carries the trace.
|
|
func recordAgent(ctx context.Context, name string, r io.ReadCloser, path string, err error) {
|
|
t := traceFrom(ctx)
|
|
candidate := ExternalPrefix + name
|
|
switch {
|
|
case r != nil:
|
|
t.add(TraceStep{Candidate: candidate, Outcome: OutcomeHit, Detail: path})
|
|
case isTransientExternal(err):
|
|
t.add(TraceStep{Candidate: candidate, Outcome: OutcomeError, Detail: err.Error()})
|
|
default:
|
|
t.add(TraceStep{Candidate: candidate, Outcome: OutcomeMiss})
|
|
}
|
|
}
|
|
|
|
// traceStage records a failure from the stages that run after the priority chain has already
|
|
// picked a winner: most ways an item can fail are here, not in the chain walk.
|
|
func traceStage(ctx context.Context, stage string, err error) {
|
|
traceFrom(ctx).add(TraceStep{Candidate: stage, Outcome: OutcomeError, Detail: err.Error()})
|
|
}
|