@belvador/cloudflare 0.4.0 → 0.4.1

package/dist/index.d.ts

@@ -19,6 +19,8 @@ export type BelvadorEnv = {
 };
 /** Engine options for one Worker invocation (exported for tests and @belvador/tanstack-start). */
 export declare function workerEngineOptions(options: WorkerOptions | undefined, env: unknown, runtime?: "cloudflare" | "tanstack-start"): EngineCloudflareOptions;
+/** Mechanism of an error from a rejected `ctx.waitUntil` promise (unhandled: nothing caught it). */
+export declare const WAIT_UNTIL_MECHANISM = "auto.faas.cloudflare.wait_until";
 /** Shared with @belvador/tanstack-start so its server events carry its own SDK name. */
 export declare function wrapHandler<Env, H>(optionsCallback: (env: Env) => WorkerOptions | undefined, handler: H, runtime: "cloudflare" | "tanstack-start"): H;
 /**

package/dist/index.js

@@ -2,7 +2,7 @@
 // Built on the open-source Sentry JavaScript SDK (MIT), with Belvador's
 // privacy and sending rules. Needs the `nodejs_compat` (or `nodejs_als`)
 // compatibility flag so every request gets its own scope.
-import { consoleIntegration, dedupeIntegration, eventFiltersIntegration, fetchIntegration, linkedErrorsIntegration, requestDataIntegration, withSentry, } from "@sentry/cloudflare";
+import { captureException, consoleIntegration, dedupeIntegration, eventFiltersIntegration, fetchIntegration, linkedErrorsIntegration, requestDataIntegration, withSentry, } from "@sentry/cloudflare";
 import { OTEL_OPTION, TRACE_OPTION, buildEngineOptions, otelBridgeIntegration, currentHooks, installTracePropagation, markHooked, noteClientAbort, runVerification, withIncomingTraceparent, } from "@belvador/core";
 export { SDK_VERSION, addBreadcrumb, captureCheckIn, captureException, captureMessage, close, flush, heartbeat, withMonitor, getDiagnostics, lastEventId, setContext, setTag, setTags, setUser, withScope, } from "@belvador/core";
 function binding(env, name) {
@@ -96,10 +96,55 @@ export function workerEngineOptions(options, env, runtime = "cloudflare") {
     }
 }
 const HANDLER_METHODS = ["fetch", "scheduled", "queue", "email", "tail"];
+/** Every module handler receives `(input, env, ctx)`; ctx is the ExecutionContext. */
+const CTX_ARG = 2;
+/** Mechanism of an error from a rejected `ctx.waitUntil` promise (unhandled: nothing caught it). */
+export const WAIT_UNTIL_MECHANISM = "auto.faas.cloudflare.wait_until";
+/**
+ * The handler's own view of ctx: `waitUntil` reports a rejected promise as an unhandled
+ * error, then hands the runtime the same rejection, so Cloudflare still logs it and the
+ * promise keeps its meaning. Everything else is the real ctx. The engine keeps the
+ * original object, so its own flush is untouched; it waits (up to its 2 s flush timeout)
+ * for promises passed here, which is what lets a late rejection still be sent.
+ */
+function reportingContext(ctx) {
+    if (ctx === null || typeof ctx !== "object")
+        return ctx;
+    try {
+        if (typeof ctx.waitUntil !== "function")
+            return ctx;
+    }
+    catch {
+        return ctx;
+    }
+    const waitUntil = (promise) => {
+        const real = Reflect.get(ctx, "waitUntil", ctx);
+        if (!isThenable(promise))
+            return real.call(ctx, promise);
+        return real.call(ctx, Promise.resolve(promise).then(undefined, (error) => {
+            try {
+                captureException(error, { mechanism: { type: WAIT_UNTIL_MECHANISM, handled: false } });
+            }
+            catch {
+                /* reporting must never change the app's behaviour */
+            }
+            throw error;
+        }));
+    };
+    return new Proxy(ctx, {
+        get(target, prop) {
+            if (prop === "waitUntil")
+                return waitUntil;
+            const value = Reflect.get(target, prop, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+}
 /**
  * Marks each invocation of an object handler as running inside the wrapper (integration
- * health: `verifyIntegration` can tell), and notes a fetch that failed after its client
- * disconnected so the error counts as a cancellation. Class handlers pass through unchanged.
+ * health: `verifyIntegration` can tell), reports rejected `ctx.waitUntil` promises, and notes
+ * a fetch that failed after its client disconnected so the error counts as a cancellation.
+ * Class handlers pass through unchanged.
  */
 function marked(handler) {
     if (handler === null || typeof handler !== "object")
@@ -109,8 +154,9 @@ function marked(handler) {
         const fn = handler[name];
         if (typeof fn !== "function")
             continue;
-        out[name] = function (...args) {
+        out[name] = function (...input) {
             markHooked("wrapper");
+            const args = input.length > CTX_ARG ? input.map((a, i) => (i === CTX_ARG ? reportingContext(a) : a)) : input;
             const signal = name === "fetch" ? signalOf(args[0]) : undefined;
             if (!signal)
                 return fn.apply(handler, args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@belvador/cloudflare",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Belvador error tracking for Cloudflare Workers: per-request scope, errors only, private by default.",
   "license": "MIT",
   "author": "Belvador (https://belvador.dev)",
@@ -32,7 +32,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@belvador/core": "0.4.0",
+    "@belvador/core": "0.4.1",
     "@sentry/cloudflare": "10.76.2"
   },
   "publishConfig": {