Files
HiveGrid-Wireframes/hivegrid-cloud/packages/error-reporter/src/index.test.ts
T

379 lines
13 KiB
TypeScript

import { describe, expect, it, vi } from "vitest";
import {
createNoopErrorReporter,
createSentryErrorReporter,
initializeTracing,
reportError,
sanitizeErrorReportValue,
shutdownTracing,
type ErrorReportEvent,
type ErrorReporter,
type NodeSdkInstance,
type NodeSdkLikeModule,
type OtlpExporterLikeModule,
type SentryInitOptions,
type SentryLikeModule,
} from "./index.js";
describe("@toolctrl/error-reporter", () => {
it("redacts nested secrets and unsafe payload keys while preserving correlation fields", () => {
const rawSecrets = [
"Bearer auth-token",
"session=abc",
"plain-password",
"nested-token",
"top-secret",
"api-key-value",
"redis://:redis-password@localhost:6379",
"postgres://user:password@localhost/database",
"person@example.com",
"template-token",
"raw request body",
"raw headers payload",
"top-level-template-token",
"nested-array-cookie",
];
const sanitized = sanitizeErrorReportValue({
component: "worker",
operation: "job.failed",
severity: "error",
requestId: "req_123",
queueName: "email",
jobId: "job_456",
retryCount: 2,
authorization: rawSecrets[0],
headers: { cookie: rawSecrets[1], raw: rawSecrets[11] },
password: rawSecrets[2],
body: rawSecrets[10],
templateData: { token: rawSecrets[12] },
nested: [
{
token: rawSecrets[3],
secret: rawSecrets[4],
apiKey: rawSecrets[5],
redisUrl: rawSecrets[6],
connectionString: rawSecrets[7],
email: rawSecrets[8],
templateData: { token: rawSecrets[9] },
body: rawSecrets[10],
recipients: [{ cookie: rawSecrets[13] }],
},
],
});
expect(sanitized).toMatchObject({
component: "worker",
operation: "job.failed",
severity: "error",
requestId: "req_123",
queueName: "email",
jobId: "job_456",
retryCount: 2,
authorization: "[Redacted]",
headers: "[Redacted]",
password: "[Redacted]",
body: "[Redacted]",
templateData: "[Redacted]",
nested: [
{
token: "[Redacted]",
secret: "[Redacted]",
apiKey: "[Redacted]",
redisUrl: "[Redacted]",
connectionString: "[Redacted]",
email: "[Redacted]",
templateData: "[Redacted]",
body: "[Redacted]",
recipients: [{ cookie: "[Redacted]" }],
},
],
});
const serialized = JSON.stringify(sanitized);
for (const rawSecret of rawSecrets) {
expect(serialized).not.toContain(rawSecret);
}
});
it("serializes Error objects without leaking enumerable secret metadata", () => {
const error = new Error("database failed");
Object.assign(error, {
token: "error-token",
safeDetail: "kept",
});
expect(sanitizeErrorReportValue({ error })).toMatchObject({
error: {
errorName: "Error",
errorMessage: "database failed",
token: "[Redacted]",
safeDetail: "kept",
},
});
});
it("swallows sync throws and async rejections from reporters", async () => {
const syncReporter: ErrorReporter = {
report() {
throw new Error("transport unavailable");
},
};
const asyncReporter: ErrorReporter = {
async report() {
throw new Error("transport rejected");
},
};
expect(() => reportError(syncReporter, { component: "api", operation: "request", errorMessage: "failed" })).not.toThrow();
expect(() => reportError(asyncReporter, { component: "api", operation: "request", errorMessage: "failed" })).not.toThrow();
await Promise.resolve();
});
it("provides a safe no-op reporter", () => {
expect(() => reportError(createNoopErrorReporter(), { component: "api", operation: "request" })).not.toThrow();
});
});
describe("createSentryErrorReporter", () => {
it("falls back to noop when @sentry/node is not installed", async () => {
const warn = vi.fn();
const reporter = createSentryErrorReporter({
dsn: "https://example@sentry.io/1",
loadSentry: async () => undefined,
onMissingDependency: warn,
});
await reporter.report({ component: "api", operation: "request" });
expect(warn).toHaveBeenCalledWith(expect.stringContaining("@sentry/node is not installed"));
});
it("falls back to noop when the DSN is empty", async () => {
const warn = vi.fn();
const reporter = createSentryErrorReporter({ dsn: "", onMissingDependency: warn });
await reporter.report({ component: "api", operation: "request" });
expect(warn).toHaveBeenCalledWith(expect.stringContaining("SENTRY_DSN is empty"));
});
it("invokes beforeSend hook and suppresses delivery when it returns null", async () => {
const captureException = vi.fn();
const captureMessage = vi.fn();
const init = vi.fn();
const fakeSentry: SentryLikeModule = { init, captureException, captureMessage };
const beforeSend = vi.fn().mockReturnValue(null);
const reporter = createSentryErrorReporter({
dsn: "https://example@sentry.io/1",
beforeSend,
loadSentry: async () => fakeSentry,
});
await reporter.report({ component: "api", operation: "request", errorMessage: "fail", token: "raw-token" });
expect(beforeSend).toHaveBeenCalledTimes(1);
const sanitizedArg = beforeSend.mock.calls[0]?.[0] as ErrorReportEvent | undefined;
expect(sanitizedArg?.token).toBe("[Redacted]");
expect(captureException).not.toHaveBeenCalled();
expect(captureMessage).not.toHaveBeenCalled();
});
it("sanitizes the event before forwarding it to Sentry capture", async () => {
const captureMessage = vi.fn();
const captureException = vi.fn();
let capturedInitOptions: SentryInitOptions | undefined;
const fakeSentry: SentryLikeModule = {
init: (opts) => {
capturedInitOptions = opts;
},
captureException,
captureMessage,
};
const reporter = createSentryErrorReporter({
dsn: "https://example@sentry.io/1",
environment: "test",
release: "test-rev",
loadSentry: async () => fakeSentry,
});
await reporter.report({
component: "worker",
operation: "job.failed",
severity: "error",
errorMessage: "boom",
authorization: "Bearer raw-token",
password: "raw",
});
expect(capturedInitOptions?.dsn).toBe("https://example@sentry.io/1");
expect(capturedInitOptions?.environment).toBe("test");
expect(capturedInitOptions?.release).toBe("test-rev");
expect(captureMessage).toHaveBeenCalledTimes(1);
const [message, context] = captureMessage.mock.calls[0] ?? [];
expect(message).toBe("boom");
const extra = (context as { extra?: ErrorReportEvent } | undefined)?.extra;
expect(extra?.authorization).toBe("[Redacted]");
expect(extra?.password).toBe("[Redacted]");
expect(captureException).not.toHaveBeenCalled();
});
});
describe("initializeTracing", () => {
it("does nothing when tracing is explicitly disabled", async () => {
const warn = vi.fn();
const loadSdk = vi.fn(async () => {
throw new Error("should not load");
});
const loadOtlpExporter = vi.fn(async () => {
throw new Error("should not load");
});
await initializeTracing({
serviceName: "api",
enabled: false,
otlpEndpoint: "http://localhost:4318/v1/traces",
loadSdk,
loadOtlpExporter,
onMissingDependency: warn,
});
expect(loadSdk).not.toHaveBeenCalled();
expect(loadOtlpExporter).not.toHaveBeenCalled();
expect(warn).not.toHaveBeenCalled();
});
it("logs a warning and skips startup when no OTLP endpoint is configured", async () => {
const warn = vi.fn();
const previousEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
delete process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
try {
await initializeTracing({ serviceName: "test", onMissingDependency: warn });
} finally {
if (previousEndpoint) {
process.env.OTEL_EXPORTER_OTLP_ENDPOINT = previousEndpoint;
}
}
expect(warn).toHaveBeenCalledWith(expect.stringContaining("OTEL_EXPORTER_OTLP_ENDPOINT"));
});
it("falls back to noop when OpenTelemetry SDK dependencies are missing", async () => {
const warn = vi.fn();
await initializeTracing({
serviceName: "test",
otlpEndpoint: "http://localhost:4318/v1/traces",
loadSdk: async () => undefined,
loadOtlpExporter: async () => undefined,
onMissingDependency: warn,
});
expect(warn).toHaveBeenCalledWith(expect.stringContaining("@opentelemetry/sdk-node"));
});
it("treats loader exceptions as missing OpenTelemetry dependencies", async () => {
const warn = vi.fn();
await initializeTracing({
serviceName: "api",
otlpEndpoint: "http://localhost:4318/v1/traces",
loadSdk: async () => {
throw new Error("sdk import failed");
},
loadOtlpExporter: async () => {
throw new Error("exporter import failed");
},
onMissingDependency: warn,
});
expect(warn).toHaveBeenCalledWith(expect.stringContaining("@opentelemetry/sdk-node or @opentelemetry/exporter-trace-otlp-http"));
});
it("logs startup failures without keeping an active tracing state", async () => {
const warn = vi.fn();
const start = vi.fn(() => {
throw new Error("start failed");
});
const shutdown = vi.fn(async () => undefined);
const sdkInstance: NodeSdkInstance = { start, shutdown };
const NodeSDK = vi.fn().mockImplementation(() => sdkInstance);
const OTLPTraceExporter = vi.fn().mockImplementation(() => ({}));
const sdkModule: NodeSdkLikeModule = { NodeSDK: NodeSDK as unknown as NodeSdkLikeModule["NodeSDK"] };
const exporterModule: OtlpExporterLikeModule = {
OTLPTraceExporter: OTLPTraceExporter as unknown as OtlpExporterLikeModule["OTLPTraceExporter"],
};
await initializeTracing({
serviceName: "api",
otlpEndpoint: "http://localhost:4318/v1/traces",
loadSdk: async () => sdkModule,
loadOtlpExporter: async () => exporterModule,
onMissingDependency: warn,
});
await shutdownTracing();
expect(warn).toHaveBeenCalledWith(expect.stringContaining("failed to start OpenTelemetry NodeSDK (start failed)"));
expect(shutdown).not.toHaveBeenCalled();
});
it("starts the NodeSDK once when both modules are present and shuts down cleanly", async () => {
const start = vi.fn();
const shutdown = vi.fn(async () => undefined);
const sdkInstance: NodeSdkInstance = { start, shutdown };
const NodeSDK = vi.fn().mockImplementation(() => sdkInstance);
const OTLPTraceExporter = vi.fn().mockImplementation(() => ({}));
const sdkModule: NodeSdkLikeModule = { NodeSDK: NodeSDK as unknown as NodeSdkLikeModule["NodeSDK"] };
const exporterModule: OtlpExporterLikeModule = {
OTLPTraceExporter: OTLPTraceExporter as unknown as OtlpExporterLikeModule["OTLPTraceExporter"],
};
await initializeTracing({
serviceName: "api",
otlpEndpoint: "http://localhost:4318/v1/traces",
loadSdk: async () => sdkModule,
loadOtlpExporter: async () => exporterModule,
});
expect(NodeSDK).toHaveBeenCalledTimes(1);
expect(OTLPTraceExporter).toHaveBeenCalledWith({ url: "http://localhost:4318/v1/traces" });
expect(start).toHaveBeenCalledTimes(1);
await initializeTracing({
serviceName: "api",
otlpEndpoint: "http://localhost:4318/v1/traces",
loadSdk: async () => sdkModule,
loadOtlpExporter: async () => exporterModule,
});
expect(NodeSDK).toHaveBeenCalledTimes(1);
await shutdownTracing();
expect(shutdown).toHaveBeenCalledTimes(1);
});
it("swallows shutdown failures", async () => {
const start = vi.fn();
const shutdown = vi.fn(async () => {
throw new Error("shutdown failed");
});
const sdkInstance: NodeSdkInstance = { start, shutdown };
const NodeSDK = vi.fn().mockImplementation(() => sdkInstance);
const OTLPTraceExporter = vi.fn().mockImplementation(() => ({}));
const sdkModule: NodeSdkLikeModule = { NodeSDK: NodeSDK as unknown as NodeSdkLikeModule["NodeSDK"] };
const exporterModule: OtlpExporterLikeModule = {
OTLPTraceExporter: OTLPTraceExporter as unknown as OtlpExporterLikeModule["OTLPTraceExporter"],
};
await initializeTracing({
serviceName: "api",
otlpEndpoint: "http://localhost:4318/v1/traces",
loadSdk: async () => sdkModule,
loadOtlpExporter: async () => exporterModule,
});
await expect(shutdownTracing()).resolves.toBeUndefined();
expect(shutdown).toHaveBeenCalledTimes(1);
});
});