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); }); });