wehub-resource-sync
98 lines
3.8 KiB
TypeScript
98 lines
3.8 KiB
TypeScript
import { createHash } from "node:crypto";
|
|
|
|
/**
|
|
* Calculate error fingerprint using Sentry-style normalization.
|
|
* Groups similar errors together by normalizing dynamic values.
|
|
*/
|
|
export function calculateErrorFingerprint(error: unknown): string {
|
|
if (!error || typeof error !== "object" || Array.isArray(error)) return "";
|
|
|
|
// This is a but ugly but…
|
|
// 1. We can't use a schema here because it's a hot path and needs to be fast.
|
|
// 2. It won't be an instanceof Error because it's from the database.
|
|
const errorObj = error as any;
|
|
const errorType = String(errorObj.type || errorObj.name || "Error");
|
|
// Fall back to the error class name, then the raw serialized value, so
|
|
// messageless errors (e.g. tagged errors) and non-Error throws (strings,
|
|
// plain objects) still group by something distinctive instead of collapsing
|
|
// into a single fingerprint. Message-bearing errors are unaffected.
|
|
const message = String(errorObj.message || errorObj.name || errorObj.raw || "");
|
|
const stack = String(errorObj.stack || errorObj.stacktrace || "");
|
|
|
|
// Normalize message to group similar errors
|
|
const normalizedMessage = normalizeErrorMessage(message);
|
|
|
|
// Extract and normalize first few stack frames
|
|
const normalizedStack = normalizeStackTrace(stack);
|
|
|
|
// Create fingerprint from type + normalized message + stack
|
|
const fingerprintInput = `${errorType}:${normalizedMessage}:${normalizedStack}`;
|
|
|
|
// Use SHA-256 hash, take first 16 chars for compact storage
|
|
return createHash("sha256").update(fingerprintInput).digest("hex").substring(0, 16);
|
|
}
|
|
|
|
/**
|
|
* Normalize error message by replacing dynamic values with placeholders.
|
|
* This allows similar errors to be grouped together.
|
|
*/
|
|
export function normalizeErrorMessage(message: string): string {
|
|
if (!message) return "";
|
|
|
|
return (
|
|
message
|
|
// UUIDs (8-4-4-4-12 format)
|
|
.replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "<uuid>")
|
|
// Run IDs (run_xxxxx format)
|
|
.replace(/run_[a-zA-Z0-9]+/g, "<run-id>")
|
|
// Task run friendly IDs (task_xxxxx or similar)
|
|
.replace(/\b[a-z]+_[a-zA-Z0-9]{8,}\b/g, "<id>")
|
|
// --- Specific patterns must run before generic numeric/path replacements ---
|
|
// ISO 8601 timestamps
|
|
.replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z?/g, "<timestamp>")
|
|
// Unix timestamps (10 or 13 digits)
|
|
.replace(/\b\d{10,13}\b/g, "<timestamp>")
|
|
// URLs (before path regex, which would strip the URL's path component)
|
|
.replace(/https?:\/\/[^\s]+/g, "<url>")
|
|
// --- Generic replacements ---
|
|
// Standalone numeric IDs (4+ digits)
|
|
.replace(/\b\d{4,}\b/g, "<id>")
|
|
// File paths (Unix style)
|
|
.replace(/(?:\/[^/\s]+){2,}/g, "<path>")
|
|
// File paths (Windows style)
|
|
.replace(/[A-Z]:\\(?:[^\\]+\\)+[^\\]+/g, "<path>")
|
|
// Email addresses
|
|
.replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g, "<email>")
|
|
// Memory addresses (0x...)
|
|
.replace(/0x[0-9a-fA-F]{8,}/g, "<addr>")
|
|
// Quoted strings with dynamic content
|
|
.replace(/"[^"]{20,}"/g, '"<string>"')
|
|
.replace(/'[^']{20,}'/g, "'<string>'")
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Normalize stack trace by taking first few frames and removing dynamic parts.
|
|
*/
|
|
export function normalizeStackTrace(stack: string): string {
|
|
if (!stack) return "";
|
|
|
|
// Take first 5 stack frames only
|
|
const lines = stack.split("\n").slice(0, 5);
|
|
|
|
return lines
|
|
.map((line) => {
|
|
// Remove line and column numbers (file.ts:123:45 -> file.ts:_:_)
|
|
line = line.replace(/:\d+:\d+/g, ":_:_");
|
|
// Remove standalone numbers
|
|
line = line.replace(/\b\d+\b/g, "_");
|
|
// Remove file paths but keep filename
|
|
line = line.replace(/(?:\/[^/\s]+)+\/([^/\s]+)/g, "$1");
|
|
// Normalize whitespace
|
|
line = line.trim();
|
|
return line;
|
|
})
|
|
.filter((line) => line.length > 0)
|
|
.join("|");
|
|
}
|