@telemetry-tracker/node 1.3.0 → 1.4.0

package/dist/fatal.d.ts

@@ -0,0 +1,17 @@
+/** Bound how long a crashing process waits for the error ingest request. */
+export declare const FATAL_FLUSH_TIMEOUT_MS = 2000;
+export type FatalFlushDeps = {
+    ingest: (error: Error, context: Record<string, unknown>) => Promise<void>;
+    exit: (code: number) => void;
+    /** Override the default {@link FATAL_FLUSH_TIMEOUT_MS}. */
+    timeoutMs?: number;
+};
+/**
+ * Report a fatal error, wait up to `timeoutMs` for ingest, then exit(1).
+ * Accepts any thrown value (null/undefined/primitives/objects).
+ * Clears the timeout when ingest settles so the timer does not keep the process alive.
+ * Telemetry-internal failures must not escape (would become Node exit code 7).
+ */
+export declare function flushFatalError(thrown: unknown, source: string, deps: FatalFlushDeps): void;
+/** @internal test helper */
+export declare function resetFatalFlushStateForTests(): void;

package/dist/fatal.js

@@ -0,0 +1,74 @@
+import { toReportableError } from "@telemetry-tracker/core";
+/** Bound how long a crashing process waits for the error ingest request. */
+export const FATAL_FLUSH_TIMEOUT_MS = 2000;
+/** Prevents double exit when strict mode raises rejection as uncaughtException too. */
+let fatalFlushInProgress = false;
+function safeExit(deps) {
+    try {
+        deps.exit(1);
+    }
+    catch {
+        // ignore — never throw from the crash handler
+    }
+}
+/**
+ * Report a fatal error, wait up to `timeoutMs` for ingest, then exit(1).
+ * Accepts any thrown value (null/undefined/primitives/objects).
+ * Clears the timeout when ingest settles so the timer does not keep the process alive.
+ * Telemetry-internal failures must not escape (would become Node exit code 7).
+ */
+export function flushFatalError(thrown, source, deps) {
+    try {
+        if (fatalFlushInProgress)
+            return;
+        fatalFlushInProgress = true;
+        const timeoutMs = deps.timeoutMs ?? FATAL_FLUSH_TIMEOUT_MS;
+        let settled = false;
+        let timeoutId;
+        let flush;
+        try {
+            const err = toReportableError(thrown);
+            let pending;
+            try {
+                pending = Promise.resolve(deps.ingest(err, { source }));
+            }
+            catch {
+                pending = Promise.resolve();
+            }
+            flush = pending.catch(() => undefined);
+        }
+        catch {
+            flush = Promise.resolve();
+        }
+        const timer = new Promise((resolve) => {
+            timeoutId = setTimeout(resolve, timeoutMs);
+            const handle = timeoutId;
+            if (typeof handle.unref === "function")
+                handle.unref();
+        });
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            fatalFlushInProgress = false;
+            if (timeoutId !== undefined) {
+                try {
+                    clearTimeout(timeoutId);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            safeExit(deps);
+        };
+        void Promise.race([flush, timer]).then(finish, finish);
+    }
+    catch {
+        fatalFlushInProgress = false;
+        safeExit(deps);
+    }
+}
+/** @internal test helper */
+export function resetFatalFlushStateForTests() {
+    fatalFlushInProgress = false;
+}

package/dist/index.d.ts

@@ -2,14 +2,50 @@ import { identify, trackEvent, trackError as coreTrackError, type TelemetryConfi
 export type TelemetryNodeConfig = TelemetryConfig & {
     app: string;
     platform?: string;
+    /**
+     * When true (default), report an unhandled rejection, flush ingest, then
+     * `process.exit(1)` — matching Node’s default crash since v15. Set `false`
+     * to only report and keep the process running (legacy 1.3.x behaviour).
+     *
+     * With `node --unhandled-rejections=strict`, rejections are also raised as
+     * uncaught exceptions; the SDK de-dupes a single fatal flush per error.
+     */
+    exitOnUnhandledRejection?: boolean;
+    /**
+     * Max ms to wait for fatal error ingest before exiting. Default 2000.
+     * The timeout is cleared when ingest settles and does not keep the process alive.
+     */
+    fatalFlushTimeoutMs?: number;
 };
+export { FATAL_FLUSH_TIMEOUT_MS, flushFatalError } from "./fatal.js";
+/** @internal Exported for unit tests. */
+export declare function createUncaughtExceptionHandler(deps: {
+    ingest: (error: Error, context: Record<string, unknown>) => Promise<void>;
+    exit: (code: number) => void;
+    timeoutMs?: number;
+}): (err: unknown) => void;
+/** @internal Exported for unit tests. */
+export declare function createUnhandledRejectionHandler(deps: {
+    exitOnUnhandledRejection: boolean;
+    ingest: (error: Error, context: Record<string, unknown>) => Promise<void>;
+    trackError: (error: Error, context: Record<string, unknown>) => void;
+    exit: (code: number) => void;
+    timeoutMs?: number;
+}): (reason: unknown) => void;
 export declare function init(config: TelemetryNodeConfig): void;
 export { identify, trackEvent, coreTrackError as trackError };
 export declare function getConfig(): TelemetryConfig | null;
+type MaybeEmitter = {
+    on?(event: string, listener: () => void): void;
+};
+/**
+ * Generic (req, res, next) middleware. Times duration until the **response**
+ * finishes (`finish`/`close`), not the request body stream.
+ */
 export declare function middleware(opts?: {
     trackRequestBody?: boolean;
 }): (req: {
     method?: string;
     url?: string;
     body?: unknown;
-}, _res: unknown, next: () => void) => void;
+}, res: MaybeEmitter | unknown, next: () => void) => void;

package/dist/index.js

@@ -1,19 +1,61 @@
-import { init as coreInit, identify, trackEvent, trackError as coreTrackError, getConfigOrNull, } from "@telemetry-tracker/core";
+import { init as coreInit, identify, trackEvent, trackError as coreTrackError, ingestError, getConfigOrNull, toReportableError, } from "@telemetry-tracker/core";
+import { FATAL_FLUSH_TIMEOUT_MS, flushFatalError } from "./fatal.js";
+export { FATAL_FLUSH_TIMEOUT_MS, flushFatalError } from "./fatal.js";
 let installed = false;
+let exitOnUnhandledRejection = true;
+let fatalFlushTimeoutMs = FATAL_FLUSH_TIMEOUT_MS;
+/** @internal Exported for unit tests. */
+export function createUncaughtExceptionHandler(deps) {
+    return (err) => {
+        flushFatalError(err, "uncaughtException", deps);
+    };
+}
+/** @internal Exported for unit tests. */
+export function createUnhandledRejectionHandler(deps) {
+    return (reason) => {
+        const err = toReportableError(reason);
+        if (deps.exitOnUnhandledRejection) {
+            flushFatalError(err, "unhandledRejection", {
+                ingest: deps.ingest,
+                exit: deps.exit,
+                timeoutMs: deps.timeoutMs,
+            });
+            return;
+        }
+        deps.trackError(err, { source: "unhandledRejection" });
+    };
+}
 function installGlobalHandlers() {
     if (installed)
         return;
     installed = true;
-    process.on("uncaughtException", (err) => {
-        coreTrackError(err, { source: "uncaughtException" });
-        throw err;
-    });
-    process.on("unhandledRejection", (reason) => {
-        const err = reason instanceof Error ? reason : new Error(String(reason));
-        coreTrackError(err, { source: "unhandledRejection" });
-    });
+    process.on("uncaughtException", createUncaughtExceptionHandler({
+        ingest: ingestError,
+        exit: (code) => process.exit(code),
+        get timeoutMs() {
+            return fatalFlushTimeoutMs;
+        },
+    }));
+    process.on("unhandledRejection", createUnhandledRejectionHandler({
+        get exitOnUnhandledRejection() {
+            return exitOnUnhandledRejection;
+        },
+        ingest: ingestError,
+        trackError: coreTrackError,
+        exit: (code) => process.exit(code),
+        get timeoutMs() {
+            return fatalFlushTimeoutMs;
+        },
+    }));
 }
 export function init(config) {
+    exitOnUnhandledRejection = config.exitOnUnhandledRejection !== false;
+    fatalFlushTimeoutMs =
+        typeof config.fatalFlushTimeoutMs === "number" &&
+            Number.isFinite(config.fatalFlushTimeoutMs) &&
+            config.fatalFlushTimeoutMs >= 0
+            ? config.fatalFlushTimeoutMs
+            : FATAL_FLUSH_TIMEOUT_MS;
     coreInit({ ...config, platform: config.platform ?? "node" });
     installGlobalHandlers();
 }
@@ -21,9 +63,13 @@ export { identify, trackEvent, coreTrackError as trackError };
 export function getConfig() {
     return getConfigOrNull();
 }
+/**
+ * Generic (req, res, next) middleware. Times duration until the **response**
+ * finishes (`finish`/`close`), not the request body stream.
+ */
 export function middleware(opts) {
     const trackRequestBody = opts?.trackRequestBody ?? false;
-    return function telemetryMiddleware(req, _res, next) {
+    return function telemetryMiddleware(req, res, next) {
         const cfg = getConfigOrNull();
         if (!cfg) {
             next();
@@ -45,15 +91,17 @@ export function middleware(opts) {
                 ...(trackRequestBody && req.body ? { body: req.body } : {}),
             });
         };
-        const reqWithOn = req;
-        if (typeof reqWithOn.on === "function") {
-            reqWithOn.on("end", done);
-            reqWithOn.on("close", done);
+        const resWithOn = res;
+        const canWatchResponse = typeof resWithOn?.on === "function";
+        if (canWatchResponse) {
+            resWithOn.on("finish", done);
+            resWithOn.on("close", done);
         }
-        else {
-            next();
+        next();
+        // Frameworks without a Node response emitter (e.g. plain objects / some
+        // Fastify adapters): record once after next(), never call next twice.
+        if (!canWatchResponse) {
             done();
         }
-        next();
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telemetry-tracker/node",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Telemetry Tracker SDK for Node.js: global error handlers, request middleware.",
   "license": "MIT",
   "repository": {
@@ -28,14 +28,17 @@
     "middleware"
   ],
   "dependencies": {
-    "@telemetry-tracker/core": "^1.3.0"
+    "@telemetry-tracker/core": "^1.5.0"
   },
   "devDependencies": {
     "@types/node": "^22.9.0",
-    "typescript": "^5.6.3"
+    "typescript": "^5.6.3",
+    "vitest": "^3.2.6"
   },
+  "gitHead": "886d9f8e0b92a78471f27b87365fc40ba7043ce1",
   "scripts": {
     "build": "tsc",
-    "dev": "tsc --watch"
+    "dev": "tsc --watch",
+    "test": "vitest run"
   }
 }