@bigbertha/sdk 0.2.0 → 0.2.1

package/README.md

@@ -97,6 +97,11 @@ init() // reads BERTHA_KEY, BERTHA_URL, BERTHA_RELEASE and NODE_ENV
 would (`handlers: false` turns that off). It also sends a heartbeat every 20 minutes so
 bertha can tell "no errors" from "not running" (`heartbeat: false`).
 
+Code that Node runs as-is needs no source maps: the SDK reads the lines around each
+frame in your own files from disk and sends them with the event (`contextLines: false`
+turns that off). It also raises V8's default stack limit from 10 frames to 50, so a
+deep framework call doesn't hide your code. A limit you set yourself is left alone.
+
 `wrapHandler(fn)` reports what a request handler throws and rethrows it.
 
 For bundled Node code, give the output debug ids and upload its maps after the build:

package/dist/core/client.d.ts

@@ -1,13 +1,16 @@
-import type { IngestException, IngestSdk } from "../generated/ingest.ts";
+import type { IngestException, IngestFrame, IngestSdk } from "../generated/ingest.ts";
 import type { CaptureContext, IngestBreadcrumb, IngestEvent, IngestUser, Options, Transport } from "./types.ts";
 export declare const MAX_BREADCRUMBS = 100;
 export declare const BATCH = 100;
 type Context = IngestEvent["context"];
+/** Adds source lines to frames, where the runtime can read the files. */
+export type AddContext = (frames: IngestFrame[]) => void;
 export declare class Client {
     readonly options: Options;
     private readonly transport;
     private readonly sdk;
     private readonly context;
+    private readonly addContext;
     private user;
     private tags;
     private crumbs;
@@ -18,7 +21,7 @@ export declare class Client {
     private window;
     private pausedUntil;
     private warned;
-    constructor(options: Options, transport: Transport, sdk: IngestSdk, context?: Context);
+    constructor(options: Options, transport: Transport, sdk: IngestSdk, context?: Context, addContext?: AddContext);
     captureException(error: unknown, ctx?: CaptureContext): string | undefined;
     captureMessage(message: string, ctx?: CaptureContext): string | undefined;
     setUser(user: IngestUser | null): void;

package/dist/core/client.js

@@ -14,6 +14,7 @@ export class Client {
     transport;
     sdk;
     context;
+    addContext;
     user;
     tags;
     crumbs = [];
@@ -24,11 +25,12 @@ export class Client {
     window = { start: 0, count: 0 };
     pausedUntil = 0;
     warned = false;
-    constructor(options, transport, sdk, context) {
+    constructor(options, transport, sdk, context, addContext) {
         this.options = options;
         this.transport = transport;
         this.sdk = sdk;
         this.context = context;
+        this.addContext = addContext;
         this.tags = { ...options.tags };
     }
     captureException(error, ctx = {}) {
@@ -38,7 +40,17 @@ export class Client {
                 return undefined;
             this.seen.add(error);
         }
-        return this.capture({ exception: toException(error, 0), level: ctx.level ?? "error" }, ctx);
+        const exception = toException(error, 0);
+        if (this.addContext) {
+            try {
+                for (let x = exception; x; x = x.cause)
+                    this.addContext(x.frames);
+            }
+            catch (e) {
+                this.log("couldn't read source lines", e);
+            }
+        }
+        return this.capture({ exception, level: ctx.level ?? "error" }, ctx);
     }
     captureMessage(message, ctx = {}) {
         return this.capture({ message, level: ctx.level ?? "warning" }, ctx);

package/dist/core/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.0";
+export declare const VERSION = "0.2.1";

package/dist/core/version.js

@@ -1 +1 @@
-export const VERSION = "0.2.0";
+export const VERSION = "0.2.1";

package/dist/generated/ingest.d.ts

@@ -108,6 +108,18 @@ export type IngestFrame = {
      * The SDK's guess; the server decides from the file path when absent.
      */
     inApp?: boolean;
+    /**
+     * Source lines around `line`, read by an SDK that can see the file (Node running
+     * its source as-is). Ignored when the frame maps through a source map.
+     */
+    context?: IngestFrameContext;
+};
+export type IngestFrameContext = {
+    /**
+     * The file's line number of `lines[0]`, from 1.
+     */
+    startLine: number;
+    lines: Array<string>;
 };
 /**
  * `POST /ingest/v1/heartbeat`: a long-running process saying it is alive, so

package/dist/node/context.d.ts

@@ -0,0 +1,10 @@
+import type { IngestFrame } from "../generated/ingest.ts";
+/** Lines either side of the frame's line, as bertha shows them. */
+export declare const CONTEXT_LINES = 5;
+/** Longer lines are cut, as bertha would. */
+export declare const LINE_CHARS = 300;
+/** Frames per exception that get lines: the ones nearest the throw matter most. */
+export declare const CONTEXT_FRAMES = 20;
+export declare function addContext(frames: IngestFrame[]): void;
+/** For tests. */
+export declare function clearContextCache(): void;

package/dist/node/context.js

@@ -0,0 +1,69 @@
+// Source lines for frames in the app's own files. Code that Node runs as-is (no bundler)
+// has no source map, so the lines come from disk; bertha prefers a map when there is one.
+import { readFileSync, statSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Lines either side of the frame's line, as bertha shows them. */
+export const CONTEXT_LINES = 5;
+/** Longer lines are cut, as bertha would. */
+export const LINE_CHARS = 300;
+/** Frames per exception that get lines: the ones nearest the throw matter most. */
+export const CONTEXT_FRAMES = 20;
+/** Bigger files are build output, not source worth reading. */
+const FILE_BYTES = 1024 * 1024;
+const CACHED_FILES = 100;
+// File → its lines, or null when it can't be read. Oldest first, for eviction.
+const cache = new Map();
+export function addContext(frames) {
+    let done = 0;
+    for (const f of frames) {
+        if (done >= CONTEXT_FRAMES)
+            break;
+        if (f.inApp === false || f.line === undefined || f.context)
+            continue;
+        const lines = read(f.file);
+        if (!lines || f.line > lines.length)
+            continue;
+        const start = Math.max(1, f.line - CONTEXT_LINES);
+        f.context = { startLine: start, lines: lines.slice(start - 1, f.line + CONTEXT_LINES).map(cut) };
+        done++;
+    }
+}
+function read(file) {
+    const path = toPath(file);
+    if (!path)
+        return null;
+    const hit = cache.get(path);
+    if (hit !== undefined)
+        return hit;
+    let lines = null;
+    try {
+        if (statSync(path).size <= FILE_BYTES)
+            lines = readFileSync(path, "utf8").split(/\r?\n/);
+    }
+    catch {
+        // Gone, moved or unreadable: no lines, and no second try.
+    }
+    cache.set(path, lines);
+    if (cache.size > CACHED_FILES)
+        cache.delete(cache.keys().next().value);
+    return lines;
+}
+function toPath(file) {
+    if (file.startsWith("file://")) {
+        try {
+            return fileURLToPath(file);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return isAbsolute(file) ? file : undefined;
+}
+function cut(line) {
+    return line.length > LINE_CHARS ? `${line.slice(0, LINE_CHARS - 1)}…` : line;
+}
+/** For tests. */
+export function clearContextCache() {
+    cache.clear();
+}

package/dist/node/index.d.ts

@@ -7,8 +7,12 @@ export interface NodeOptions extends Partial<Options> {
     handlers?: boolean;
     /** Tell bertha the process is alive every 20 minutes. On by default. */
     heartbeat?: boolean;
+    /** Send the source lines around each frame in your code, read from disk. On by default. */
+    contextLines?: boolean;
 }
 export declare const HEARTBEAT_MS: number;
+/** V8 keeps 10 frames, which a framework's own calls can use up before reaching yours. */
+export declare const STACK_FRAMES = 50;
 /** Reads BERTHA_KEY, BERTHA_URL, BERTHA_RELEASE and NODE_ENV unless given. */
 export declare function init(options?: NodeOptions): Client | undefined;
 export declare function sendHeartbeat(o: Pick<Options, "url" | "key" | "release" | "environment">): Promise<boolean>;

package/dist/node/index.js

@@ -1,5 +1,6 @@
-// @bigbertha/sdk/node: uncaught exceptions and unhandled rejections, a heartbeat so
-// quiet hours read as "no errors" rather than "no data", and a handler wrapper.
+// @bigbertha/sdk/node: uncaught exceptions and unhandled rejections, source lines from
+// disk, a heartbeat so quiet hours read as "no errors" rather than "no data", and a
+// handler wrapper.
 import { arch, platform } from "node:os";
 import { gzipSync } from "node:zlib";
 import { Client } from "../core/client.js";
@@ -7,8 +8,12 @@ import { firstEnv } from "../core/env.js";
 import { getClient, setClient } from "../core/hub.js";
 import { endpoint, fetchTransport } from "../core/transport.js";
 import { VERSION } from "../core/version.js";
+import { addContext } from "./context.js";
 export { addBreadcrumb, captureException, captureMessage, flush, getClient, setTag, setUser } from "../core/hub.js";
 export const HEARTBEAT_MS = 20 * 60 * 1000;
+/** V8 keeps 10 frames, which a framework's own calls can use up before reaching yours. */
+export const STACK_FRAMES = 50;
+const V8_DEFAULT_FRAMES = 10;
 const EXIT_FLUSH_MS = 2000;
 let handlersInstalled = false;
 let heartbeat;
@@ -27,8 +32,11 @@ export function init(options = {}) {
         release: options.release ?? firstEnv("BERTHA_RELEASE"),
         environment: options.environment ?? firstEnv("BERTHA_ENVIRONMENT", "VERCEL_ENV", "NODE_ENV"),
     };
-    const client = new Client(opts, fetchTransport({ url, key, gzip: async (body) => new Uint8Array(gzipSync(body)) }), { name: "bertha.node", version: VERSION }, { runtime: `Node ${process.versions.node}`, os: `${platform()} ${arch()}` });
+    const client = new Client(opts, fetchTransport({ url, key, gzip: async (body) => new Uint8Array(gzipSync(body)) }), { name: "bertha.node", version: VERSION }, { runtime: `Node ${process.versions.node}`, os: `${platform()} ${arch()}` }, options.contextLines === false ? undefined : addContext);
     setClient(client);
+    // Only V8's default: a limit the app set itself was a choice.
+    if (Error.stackTraceLimit === V8_DEFAULT_FRAMES)
+        Error.stackTraceLimit = STACK_FRAMES;
     if (options.handlers !== false && !handlersInstalled) {
         handlersInstalled = true;
         process.on("uncaughtException", sdkHandler((error) => void crash("uncaughtException", error)));

package/package.json

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