379 lines
13 KiB
TypeScript
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);
|
|
});
|
|
});
|