File size: 5,946 Bytes
bc4a7e8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 | /**
* Structured Logger — FASE-05 Code Quality
*
* Lightweight structured logging wrapper with JSON output for production
* and human-readable output for development. Replaces scattered console.log
* calls with consistent, parseable log entries.
*
* When APP_LOG_TO_FILE is enabled, log entries are also appended as JSON lines
* to the application log file for the Console Log Viewer.
*
* @module shared/utils/structuredLogger
*/
import { getCorrelationId } from "../middleware/correlationId";
import { appendFileSync, existsSync, mkdirSync } from "fs";
import { dirname, resolve } from "path";
import { getAppLogFilePath, getAppLogLevel, getAppLogToFile } from "@/lib/logEnv";
const LOG_LEVELS: Record<string, number> = {
debug: 10,
info: 20,
warn: 30,
error: 40,
fatal: 50,
};
const currentLevel = LOG_LEVELS[getAppLogLevel("info").toLowerCase() || ""] || LOG_LEVELS.info;
const isProduction = process.env.NODE_ENV === "production";
// File logging configuration
const logToFile = getAppLogToFile();
const logFilePath = resolve(getAppLogFilePath());
// Ensure log directory exists once at module load
if (logToFile) {
try {
const dir = dirname(logFilePath);
if (!existsSync(dir)) {
mkdirSync(dir, { recursive: true });
}
} catch {
// silently ignore — will retry on each write
}
}
/**
* Append a JSON log line to the log file (non-blocking best-effort).
*/
function writeToFile(entry: Record<string, unknown>) {
if (!logToFile) return;
try {
appendFileSync(logFilePath, JSON.stringify(entry) + "\n");
} catch {
// Silently fail — file logging should never break the app
}
}
function formatEntry(
level: string,
component: string,
message: string,
meta?: Record<string, unknown>
) {
const entry: Record<string, unknown> = {
timestamp: new Date().toISOString(),
level,
component,
message,
...meta,
};
// Add correlation ID if available
const correlationId = getCorrelationId() as string | undefined;
if (correlationId) {
entry.correlationId = correlationId;
}
if (isProduction) {
return JSON.stringify(entry);
}
// Human-readable for development
const metaStr = meta && Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : "";
const corrStr = correlationId ? ` [${correlationId.slice(0, 8)}]` : "";
return `[${entry.timestamp}] ${level.toUpperCase().padEnd(5)} [${component}]${corrStr} ${message}${metaStr}`;
}
function buildEntry(
level: string,
component: string,
message: string,
meta?: Record<string, unknown>
) {
const entry: Record<string, unknown> = {
timestamp: new Date().toISOString(),
level,
component,
message,
...meta,
};
const correlationId = getCorrelationId() as string | undefined;
if (correlationId) {
entry.correlationId = correlationId;
}
return entry;
}
// EPIPE-safe error deduplication + rate limiting (#1006)
const _recentErrors = new Map<string, { count: number; firstSeen: number }>();
const DEDUP_WINDOW_MS = 5_000;
const MAX_WRITES_PER_SECOND = 50;
let _writeCount = 0;
let _writeWindowStart = Date.now();
function shouldSuppressError(message: string): boolean {
const now = Date.now();
// Rate limit: max writes per second
if (now - _writeWindowStart > 1000) {
_writeCount = 0;
_writeWindowStart = now;
}
if (_writeCount >= MAX_WRITES_PER_SECOND) return true;
// Dedup: suppress identical messages within window
const existing = _recentErrors.get(message);
if (existing && now - existing.firstSeen < DEDUP_WINDOW_MS) {
existing.count++;
return true;
}
// Cleanup old entries
if (_recentErrors.size > 100) {
for (const [key, entry] of _recentErrors) {
if (now - entry.firstSeen > DEDUP_WINDOW_MS) _recentErrors.delete(key);
}
}
_recentErrors.set(message, { count: 1, firstSeen: now });
_writeCount++;
return false;
}
export function createLogger(component: string) {
return {
debug(message: string, meta?: Record<string, unknown>) {
if (currentLevel <= LOG_LEVELS.debug) {
const entry = buildEntry("debug", component, message, meta);
console.debug(formatEntry("debug", component, message, meta));
writeToFile(entry);
}
},
info(message: string, meta?: Record<string, unknown>) {
if (currentLevel <= LOG_LEVELS.info) {
const entry = buildEntry("info", component, message, meta);
console.info(formatEntry("info", component, message, meta));
writeToFile(entry);
}
},
warn(message: string, meta?: Record<string, unknown>) {
if (currentLevel <= LOG_LEVELS.warn) {
const entry = buildEntry("warn", component, message, meta);
console.warn(formatEntry("warn", component, message, meta));
writeToFile(entry);
}
},
error(message: string, meta?: Record<string, unknown>) {
if (currentLevel <= LOG_LEVELS.error) {
if (shouldSuppressError(message)) return;
const entry = buildEntry("error", component, message, meta);
// Use stderr.write to avoid Next.js console patching that triggers EPIPE loops
try {
process.stderr.write(formatEntry("error", component, message, meta) + "\n");
} catch {}
writeToFile(entry);
}
},
fatal(message: string, meta?: Record<string, unknown>) {
if (shouldSuppressError(message)) return;
const entry = buildEntry("fatal", component, message, meta);
try {
process.stderr.write(formatEntry("fatal", component, message, meta) + "\n");
} catch {}
writeToFile(entry);
},
child(defaultMeta: Record<string, unknown>) {
return createLogger(component);
},
};
}
export { LOG_LEVELS };
|