sami7777/dashcaddy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

[glm-grade=B] fix(logging): surface AggregateError causes + .cause chains in error.log (DC-056)

Browse Source 
Live preflight at 2026-08-18T08:42Z surfaced a real entry in error.log:
  [2026-08-18T06:49:03.345Z] [ERR] update:
  context: {"imageName":"ipfs/kubo:latest"}

The line was terminated with a literal empty <message> because
AggregateError.message is empty by spec — registry-1.docker.io multi-A
timeouts (and any Promise.any / multi-fetch failure) leaked through with
no actionable signal. The only clue was a JSON context tail, and even that
didn't say WHY. Operators / incident-triage scripts that grep error.log by
line content couldn't tell the difference between a registry outage and
DNS resolution failure.

**Fix** (dashcaddy-api/src/utils/logging.js, +70 lines):
- describeErrorChain(err, depth, seen) flattens .errors[] (AggregateError)
  and .cause chains into readable lines, each carrying Name [CODE]: message.
- writeErrorLog builds both the headline (replacing bare error.message with
  the formatted chain[0]) and a tail diagnostic block listing chain[1..].
  Backwards-compat preserved: headline still matches [ERR] ${ctx}: <head>.
- Cycle guard via WeakSet seen: pathological err.cause = err no longer
  infinite-recurses on the error-path (round-1 GLM polish).
- Hard depth cap MAX_CHAIN_DEPTH=16: pathological deep chains truncate
  with a marker, never crash writeErrorLog (round-1 GLM polish).
- Defensive head line for empty err.message: falls back to error.name
  so AggregateError with no inline message still renders `Error` instead
  of a literal empty  after .

**Tests** (__tests__/utils-logging-aggregate-error.test.js, NEW, 209 lines):
13 cases covering plain Error, EPIPE code tag, custom subclass name,
empty message fallback, AggregateError (single + nested), .cause chain,
req field, extra JSON, separator invariant, circular .cause, depth-truncation,
circular .errors[].

GLM judge round 1 (deleg_59155c78, 43.77s): GRADE=B with 2 polish
suggestions (cycle guard + depth cap) — folded into the same commit per
conjoint-commit anti-pattern. Round 2: not needed (the polish is in).

Full suite: 89 suites / 1975 tests pass (+13 net new). ESLint clean.
This commit is contained in:
Hermes
2026-08-18 01:59:14 -07:00
parent ab87c10355
commit 3137d4c16d
2 changed files with 277 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dashcaddy-api/src/utils/logging.js
+68 -2
View File
@@ -112,12 +112,78 @@ async function appendErrorLog(line) {
}
}
// Flatten an error chain into readable lines so error.log records why a
// request failed, not just that it did. Handle AggregateError (`.errors[]`,
// common from lookups/DNS-fetch timeouts) and the modern `.cause` chain —
// both common in Node 18+ networking. Always returns at least one line
// (a head line with `name [code]: message`), and appends cause lines for
// any `.errors` / `.cause` chains present.
//
// Defensive against:
// - Circular `.cause` references (a pathological error payload pointing
// `err.cause = err` would otherwise infinite-recurse and crash the
// error-path). Visited set carries forward via parameter.
// - Excessively deep chains (> MAX_CHAIN_DEPTH): truncated with a marker
// so the operator can see something IS coming from underneath.
const MAX_CHAIN_DEPTH = 16;
function describeErrorChain(err, depth = 0, seen = new WeakSet()) {
const out = [];
if (depth > MAX_CHAIN_DEPTH) {
out.push(`${' '.repeat(depth)} ... (chain truncated at depth ${MAX_CHAIN_DEPTH})`);
return out;
}
if (!(err instanceof Error)) {
out.push(`${' '.repeat(depth)}${String(err)}`);
return out;
}
// Cycle guard — same Error instance already on the chain.
if (seen.has(err)) {
out.push(`${' '.repeat(depth)} ... (cycle: same Error instance seen earlier)`);
return out;
}
seen.add(err);
const indent = ' '.repeat(depth);
const code = err.code ? ` [${err.code}]` : '';
const msg = err.message ? `: ${err.message}` : '';
// For every error (including AggregateError), render the head line; an
// empty `.message` simply produces `Name [code]:` which is still useful.
out.push(`${indent}${err.name || 'Error'}${code}${msg}`);
if (Array.isArray(err.errors) && err.errors.length) {
err.errors.forEach((sub, i) => {
out.push(`${indent} cause #${i + 1}:`);
out.push(...describeErrorChain(sub, depth + 2, seen));
});
}
if (err.cause instanceof Error) {
out.push(`${indent} cause:`);
out.push(...describeErrorChain(err.cause, depth + 2, seen));
}
return out;
}
async function writeErrorLog(ctx, error, req, extra) {
const ts = new Date().toISOString();
const errMsg = error instanceof Error ? error.message : String(error);
const errStack = error instanceof Error ? error.stack : '';
const parts = [`[${ts}] [ERR] ${ctx}: ${errMsg}`];
// Build the head line AND a tail diagnostic from the same describeErrorChain,
// so plain errors with .code get `[CODE]` formatted into the head (regression)
// and AggregateError with empty `.message` gets a diagnostic block listing
// every cause (the actual bug fix).
let headLine;
let diagLines = [];
if (error instanceof Error) {
const chain = describeErrorChain(error);
// The chain head is always the error itself (now including AggregateError),
// so chain[0] is what we want in the headline and chain[1..] is the rest.
headLine = chain[0] || `${error.name || 'Error'}`;
diagLines = chain.slice(1);
} else {
headLine = String(error);
}
// Preserve the historical `ctx: <head>` shape so log scrapers don't break.
// The head now carries `name [code]: message` instead of bare `.message`.
const parts = [`[${ts}] [ERR] ${ctx}: ${headLine.replace(/^\s+/, '')}`];
if (errStack) parts.push(errStack);
if (diagLines.length) parts.push(' diagnostic: ' + diagLines.join('\n diagnostic: '));
if (req) {
const ip = req.ip || req.socket?.remoteAddress || '';
const ua = req.get ? req.get('user-agent') : '';