@bigbertha/sdk 0.5.0 → 0.5.1

package/README.md

@@ -156,7 +156,26 @@ deep framework call doesn't hide your code. A limit you set yourself is left alo
 request: its URL, its headers (never `authorization`, `proxy-authorization`, `cookie`,
 `set-cookie` or `x-api-key`), the client IP from the first `x-forwarded-for` hop or the
 socket, and the trace from an incoming `traceparent`. Next.js's `onRequestError` sends
-the same. Server events also name the host (Heroku's `DYNO`, else the hostname) and the
+the same.
+
+An app with its own error middleware passes the framework's request as `req` and gets
+the same request, IP and trace:
+
+```ts
+// Koa
+app.on("error", (err, ctx) =>
+  captureException(err, { req: ctx, status: err.status ?? 500, mechanism: { handler: "koa", handled: false } }),
+)
+// Express, after the routes
+app.use((err, req, res, next) => {
+  captureException(err, { req, status: 500, mechanism: { handler: "express", handled: false } })
+  next(err)
+})
+```
+
+`req` takes Node's `IncomingMessage`, Express's `req`, Koa's `ctx` or a Fetch `Request`
+(the edge entry too). `mechanism` says the error escaped the app's own code, so bertha
+doesn't read it as one the app caught. Server events also name the host (Heroku's `DYNO`, else the hostname) and the
 Node and Next.js versions.
 
 For bundled Node code, give the output debug ids and upload its maps after the build:

package/dist/core/client.d.ts

@@ -7,6 +7,8 @@ type Context = IngestEvent["context"];
 export type AddContext = (frames: IngestFrame[]) => void;
 /** Adds what the runtime knows at capture time (the page, its state). Runs before scrubbing. */
 export type Enrich = (event: IngestEvent) => void;
+/** Reads a framework's request passed as `req`. Server entries only, to keep the browser small. */
+export type ReadRequest = (req: unknown) => CaptureContext;
 export declare class Client {
     readonly options: Options;
     private readonly transport;
@@ -14,6 +16,7 @@ export declare class Client {
     private readonly context;
     private readonly addContext;
     private readonly enrich;
+    private readonly readRequest;
     private user;
     private tags;
     private crumbs;
@@ -24,7 +27,7 @@ export declare class Client {
     private window;
     private pausedUntil;
     private warned;
-    constructor(options: Options, transport: Transport, sdk: IngestSdk, context?: Context, addContext?: AddContext, enrich?: Enrich);
+    constructor(options: Options, transport: Transport, sdk: IngestSdk, context?: Context, addContext?: AddContext, enrich?: Enrich, readRequest?: ReadRequest);
     captureException(error: unknown, ctx?: CaptureContext): string | undefined;
     captureMessage(message: string, ctx?: CaptureContext): string | undefined;
     setUser(user: IngestUser | null): void;

package/dist/core/client.js

@@ -21,6 +21,7 @@ export class Client {
     context;
     addContext;
     enrich;
+    readRequest;
     user;
     tags;
     crumbs = [];
@@ -31,13 +32,14 @@ export class Client {
     window = { start: 0, count: 0 };
     pausedUntil = 0;
     warned = false;
-    constructor(options, transport, sdk, context, addContext, enrich) {
+    constructor(options, transport, sdk, context, addContext, enrich, readRequest) {
         this.options = options;
         this.transport = transport;
         this.sdk = sdk;
         this.context = context;
         this.addContext = addContext;
         this.enrich = enrich;
+        this.readRequest = readRequest;
         this.tags = { ...options.tags };
     }
     captureException(error, ctx = {}) {
@@ -101,6 +103,9 @@ export class Client {
         if (++this.window.count > PER_MINUTE)
             return undefined;
         const id = uuid();
+        const fromReq = (ctx.req !== undefined && this.readRequest?.(ctx.req)) || {};
+        const request = ctx.request ?? fromReq.request;
+        const user = fromReq.user || ctx.user ? { ...fromReq.user, ...ctx.user } : undefined;
         let event = {
             ...base,
             id,
@@ -108,12 +113,12 @@ export class Client {
             release: o.release ?? builtRelease(),
             environment: o.environment,
             breadcrumbs: this.crumbs.slice(),
-            user: ctx.user ? { ...this.user, ...ctx.user } : this.user,
+            user: user ? { ...this.user, ...user } : this.user,
             context: { ...this.context, versions: { ...versions(), ...o.versions, ...this.context?.versions } },
             tags: { ...this.tags, ...ctx.tags },
             fingerprint: ctx.fingerprint,
-            request: ctx.request,
-            trace: ctx.trace,
+            request: request && ctx.status !== undefined ? { ...request, status: ctx.status } : request,
+            trace: ctx.trace ?? fromReq.trace,
         };
         try {
             this.enrich?.(event);

package/dist/core/request.d.ts

@@ -4,3 +4,9 @@ import type { CaptureContext } from "./types.ts";
  * (the first proxy hop, else the socket) and the trace from an incoming `traceparent`.
  */
 export declare function fromRequest(method: string, url: string, headers: Record<string, unknown>, remoteAddress?: string): CaptureContext;
+/**
+ * The same from a framework's own request: Node's `IncomingMessage`, Express's `req`,
+ * Koa's `ctx` or `ctx.req`, or a Fetch `Request` (edge, Hono's `c.req.raw`). Anything
+ * else gives nothing.
+ */
+export declare function fromAnyRequest(req: unknown): CaptureContext;

package/dist/core/request.js

@@ -29,3 +29,26 @@ export function fromRequest(method, url, headers, remoteAddress) {
         ctx.trace = trace;
     return ctx;
 }
+/**
+ * The same from a framework's own request: Node's `IncomingMessage`, Express's `req`,
+ * Koa's `ctx` or `ctx.req`, or a Fetch `Request` (edge, Hono's `c.req.raw`). Anything
+ * else gives nothing.
+ */
+export function fromAnyRequest(req) {
+    const r = req;
+    if (!r || typeof r !== "object" || typeof r.method !== "string" || !r.headers || typeof r.headers !== "object")
+        return {};
+    let headers;
+    if (typeof r.headers.forEach === "function") {
+        headers = {};
+        r.headers.forEach((v, k) => (headers[k] = v));
+    }
+    else
+        headers = r.headers;
+    const path = typeof r.originalUrl === "string" ? r.originalUrl : typeof r.url === "string" ? r.url : "/";
+    const first = (v) => (typeof v === "string" ? v.split(",")[0]?.trim() : undefined);
+    const host = first(headers.host) ?? first(headers.Host);
+    const proto = first(headers["x-forwarded-proto"]) ?? "http";
+    const url = host && path.startsWith("/") ? `${proto}://${host}${path}` : path;
+    return fromRequest(r.method, url, headers, r.socket?.remoteAddress);
+}

package/dist/core/types.d.ts

@@ -27,6 +27,14 @@ export interface CaptureContext {
     tags?: Record<string, string>;
     fingerprint?: string[];
     request?: IngestEvent["request"];
+    /**
+     * The framework's request: Node's `IncomingMessage`, Express's `req`, Koa's `ctx`, or a
+     * Fetch `Request`. Its method, URL, headers (never credentials), the client IP and an
+     * incoming `traceparent` are sent. `request`, `user` and `trace` win over what it gives.
+     */
+    req?: unknown;
+    /** The response status, sent with the request. */
+    status?: number;
     /** Merged over the user from `setUser`. */
     user?: IngestUser;
     /** How the error reached the SDK. Defaults to `captureException`, handled. */

package/dist/core/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.5.0";
+export declare const VERSION = "0.5.1";

package/dist/core/version.js

@@ -1 +1 @@
-export const VERSION = "0.5.0";
+export const VERSION = "0.5.1";

package/dist/edge/index.js

@@ -3,6 +3,7 @@
 import { Client } from "../core/client.js";
 import { firstEnv } from "../core/env.js";
 import { setClient } from "../core/hub.js";
+import { fromAnyRequest } from "../core/request.js";
 import { fetchTransport, streamGzip } from "../core/transport.js";
 import { VERSION } from "../core/version.js";
 export { addBreadcrumb, captureException, captureMessage, flush, getClient, setTag, setUser } from "../core/hub.js";
@@ -19,7 +20,7 @@ export function init(options = {}) {
         url,
         release: options.release ?? firstEnv("BERTHA_RELEASE"),
         environment: options.environment ?? firstEnv("BERTHA_ENVIRONMENT", "VERCEL_ENV", "NODE_ENV"),
-    }, fetchTransport({ url, key, gzip: streamGzip }), { name: "bertha.edge", version: VERSION }, { runtime: "Edge" });
+    }, fetchTransport({ url, key, gzip: streamGzip }), { name: "bertha.edge", version: VERSION }, { runtime: "Edge" }, undefined, undefined, fromAnyRequest);
     setClient(client);
     return client;
 }

package/dist/node/index.js

@@ -7,7 +7,7 @@ import { gzipSync } from "node:zlib";
 import { Client } from "../core/client.js";
 import { envCommit, firstEnv } from "../core/env.js";
 import { getClient, setClient } from "../core/hub.js";
-import { fromRequest } from "../core/request.js";
+import { fromAnyRequest } from "../core/request.js";
 import { endpoint, fetchTransport } from "../core/transport.js";
 import { VERSION } from "../core/version.js";
 import { addContext } from "./context.js";
@@ -39,7 +39,7 @@ export function init(options = {}) {
         os: `${platform()} ${arch()}`,
         host: process.env.DYNO ?? safe(hostname),
         versions: installedVersions(),
-    }, options.contextLines === false ? undefined : addContext);
+    }, options.contextLines === false ? undefined : addContext, undefined, fromAnyRequest);
     setClient(client);
     // Only V8's default: a limit the app set itself was a choice.
     if (Error.stackTraceLimit === V8_DEFAULT_FRAMES)
@@ -106,7 +106,7 @@ export async function sendHeartbeat(o) {
 export function wrapHandler(handler) {
     return function (...args) {
         const report = (error) => {
-            getClient()?.captureException(error, requestContext(args[0]));
+            getClient()?.captureException(error, { req: args[0], mechanism: { handler: "wrapHandler", handled: false } });
             throw error;
         };
         try {
@@ -118,16 +118,6 @@ export function wrapHandler(handler) {
         }
     };
 }
-function requestContext(req) {
-    const r = req;
-    if (!r || typeof r.method !== "string")
-        return {};
-    const path = r.originalUrl ?? r.url ?? "/";
-    const host = typeof r.headers?.host === "string" ? r.headers.host : undefined;
-    const proto = typeof r.headers?.["x-forwarded-proto"] === "string" ? r.headers["x-forwarded-proto"] : "http";
-    const url = host && path.startsWith("/") ? `${proto}://${host}${path}` : path;
-    return fromRequest(r.method, url, r.headers ?? {}, r.socket?.remoteAddress);
-}
 /** Node's version, and Next.js's when the app has it installed. */
 function installedVersions() {
     const out = { node: process.versions.node };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bigbertha/sdk",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Error reporting for bertha: browser, React, Node, edge and Next.js, with source maps by debug id.",
   "license": "MIT",
   "repository": {