@bigbertha/sdk 0.1.3 → 0.1.5

package/README.md

@@ -55,7 +55,20 @@ import { withBertha } from "@bigbertha/sdk/next/config"
 export default withBertha({ /* your config */ })
 ```
 
-`withBertha` options: `release`, `keepMaps` (default false), `disableUpload`.
+`withBertha` options: `release`, `keepMaps`, `disableUpload`. It removes the maps under
+`.next/static` (the ones browsers can fetch) and keeps the server's, which aren't served
+and which Vercel's build output can need. `keepMaps` takes `true`, `false` or a function
+of the path inside `.next`. It also stamps the environment, so a Vercel preview reports
+as staging.
+
+For your own options (`beforeSend`, `tags`, `sampleRate`), call `init` from
+`@bigbertha/sdk/browser` in `instrumentation-client.ts` instead of importing
+`next/client`, and `init` from `@bigbertha/sdk/node` in `register()`. The build plugin
+works the same either way, and it keeps the debug ids another tool (such as Sentry's
+plugin) already gave the bundles, so both can run side by side. Wrap it inside
+`withSentryConfig` and set Sentry's `sourcemaps.deleteSourcemapsAfterUpload: false`:
+Sentry's plugin runs first, and the maps it deletes never reach bertha. bertha removes
+the served ones afterwards.
 
 ## Vite (browser)
 
@@ -118,7 +131,7 @@ await flush()
 | --- | --- | --- |
 | `key`, `url` | from env (Node, edge) | Required in the browser. |
 | `release` | stamped at build time | The plugins stamp it from `BERTHA_RELEASE`, the CI's commit sha or `git HEAD`. |
-| `environment` | `BERTHA_ENVIRONMENT` or `NODE_ENV` (Node, edge), else production | Free text is mapped to production, staging or development. |
+| `environment` | `BERTHA_ENVIRONMENT`, `VERCEL_ENV` or `NODE_ENV` (Node, edge; `withBertha` stamps it for the browser), else production | Free text is mapped to production, staging or development. |
 | `sampleRate` | `1` | Share of events to send. |
 | `beforeSend` | | Change an event, or return `null` to drop it. |
 | `scrub` | `true` | Redact emails, bearer tokens and secret query values. |

package/dist/build/index.d.ts

@@ -32,8 +32,11 @@ export interface Report {
 export declare function processDirectory(o: ProcessOptions): Promise<Report>;
 /** A stable UUID from the bundle's content, so rebuilding the same code gives the same id. */
 export declare function idFor(code: string): string;
-/** The line appended to a bundle. Runs once when the bundle loads; never throws. */
-export declare function snippet(debugId: string, release?: string): string;
+/**
+ * The line appended to a bundle. Runs once when the bundle loads; never throws.
+ * `comment: false` leaves out the `//# debugId=` comment, for a bundle that has one.
+ */
+export declare function snippet(debugId: string, release?: string, comment?: boolean): string;
 /** Appends the snippet, before a trailing sourceMappingURL comment if there is one. */
-export declare function stamp(code: string, debugId: string, release?: string): string;
+export declare function stamp(code: string, debugId: string, release?: string, comment?: boolean): string;
 export declare function reason(res: Response): Promise<string>;

package/dist/build/index.js

@@ -2,7 +2,8 @@
 // to bertha, and take them out of the output so they aren't served.
 //
 // The id goes in a line appended to the bundle. Appending (never prepending) keeps
-// every existing mapping valid. At runtime that line records the bundle's own URL
+// every existing mapping valid. A bundle that already has a debug id (from Sentry's
+// plugin, or Rollup's `sourcemapDebugIds`) keeps it, and still gets bertha's line. At runtime that line records the bundle's own URL
 // from `new Error().stack` against its id, so events can name the map for each frame
 // wherever the file was served from.
 import { createHash } from "node:crypto";
@@ -15,6 +16,8 @@ const JS = /\.(?:m|c)?js$/;
 const ORPHAN_MAP = /\.(?:m|c)?js\.map$/;
 const MAP_COMMENT = /\n?\/\/[#@] sourceMappingURL=(\S+)[ \t]*\r?\n?$/;
 const DEBUG_ID_COMMENT = /\/\/# debugId=([0-9a-fA-F-]{36})/;
+/** In every bundle this step has already stamped, so a second run changes nothing. */
+const REGISTERED = "g.__berthaIds=";
 const CONCURRENCY = 4;
 const UPLOAD_TIMEOUT_MS = 60_000;
 export async function processDirectory(o) {
@@ -44,7 +47,7 @@ export async function processDirectory(o) {
         const json = JSON.parse(map.text);
         json.debugId = debugId;
         const mapText = JSON.stringify(json);
-        let out = DEBUG_ID_COMMENT.test(code) ? code : stamp(code, debugId, o.release);
+        let out = code.includes(REGISTERED) ? code : stamp(code, debugId, o.release, !DEBUG_ID_COMMENT.test(code));
         if (keep && map.path)
             await writeFile(map.path, mapText);
         else if (!keep) {
@@ -116,18 +119,22 @@ export function idFor(code) {
     const variant = ((parseInt(h[16], 16) & 0x3) | 0x8).toString(16);
     return `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-${variant}${h.slice(17, 20)}-${h.slice(20, 32)}`;
 }
-/** The line appended to a bundle. Runs once when the bundle loads; never throws. */
-export function snippet(debugId, release) {
+/**
+ * The line appended to a bundle. Runs once when the bundle loads; never throws.
+ * `comment: false` leaves out the `//# debugId=` comment, for a bundle that has one.
+ */
+export function snippet(debugId, release, comment = true) {
     const r = release ? `g.__berthaRelease=${JSON.stringify(release)}` : "";
     return (`;!function(){try{var g=typeof globalThis<"u"?globalThis:self,s=(new Error).stack;` +
-        `s&&((g.__berthaIds=g.__berthaIds||{})[s]="${debugId}");${r}}catch(e){}}();\n//# debugId=${debugId}\n`);
+        `s&&((${REGISTERED}g.__berthaIds||{})[s]="${debugId}");${r}}catch(e){}}();\n` +
+        (comment ? `//# debugId=${debugId}\n` : ""));
 }
 /** Appends the snippet, before a trailing sourceMappingURL comment if there is one. */
-export function stamp(code, debugId, release) {
+export function stamp(code, debugId, release, comment = true) {
     const m = MAP_COMMENT.exec(code);
     const body = m ? code.slice(0, m.index) : code;
     const tail = m ? m[0].replace(/^\n?/, "") : "";
-    return `${body.endsWith("\n") ? body : `${body}\n`}${snippet(debugId, release)}${tail}`;
+    return `${body.endsWith("\n") ? body : `${body}\n`}${snippet(debugId, release, comment)}${tail}`;
 }
 async function upload(o, q, map) {
     const f = o.fetch ?? fetch;

package/dist/core/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.3";
+export declare const VERSION = "0.1.5";

package/dist/core/version.js

@@ -1 +1 @@
-export const VERSION = "0.1.3";
+export const VERSION = "0.1.5";

package/dist/edge/index.js

@@ -18,7 +18,7 @@ export function init(options = {}) {
         key,
         url,
         release: options.release ?? firstEnv("BERTHA_RELEASE"),
-        environment: options.environment ?? firstEnv("BERTHA_ENVIRONMENT", "NODE_ENV"),
+        environment: options.environment ?? firstEnv("BERTHA_ENVIRONMENT", "VERCEL_ENV", "NODE_ENV"),
     }, fetchTransport({ url, key, gzip: streamGzip }), { name: "bertha.edge", version: VERSION }, { runtime: "Edge" });
     setClient(client);
     return client;

package/dist/next/client.js

@@ -23,7 +23,7 @@ else if (key && url) {
         key,
         url,
         release: read(() => process.env.BERTHA_RELEASE),
-        environment: read(() => process.env.NODE_ENV),
+        environment: read(() => process.env.BERTHA_ENVIRONMENT) ?? read(() => process.env.NODE_ENV),
     });
 }
 else {

package/dist/next/config.d.ts

@@ -1,8 +1,13 @@
 export interface BerthaNextOptions {
     release?: string;
-    /** Keep .map files in `.next` after uploading. Default false. */
-    keepMaps?: boolean;
+    /**
+     * Which .map files stay in `.next` after uploading, by path inside it. Defaults to
+     * the server's: only `static/` is served to browsers, and removing server maps can
+     * break Vercel's build output (getsentry/sentry-javascript#13099).
+     */
+    keepMaps?: boolean | ((file: string) => boolean);
     /** Skip the post-build step entirely (the release is still stamped). */
     disableUpload?: boolean;
 }
+export declare const keepServerMaps: (file: string) => boolean;
 export declare function withBertha<C extends object>(config?: C, options?: BerthaNextOptions): C;

package/dist/next/config.js

@@ -1,18 +1,25 @@
 // @bigbertha/sdk/next/config, for next.config.ts:
 //   export default withBertha(nextConfig)
-// Turns on source maps for production builds, stamps the release, and after each
+// Turns on source maps for production builds, stamps the release and environment
+// (BERTHA_ENVIRONMENT, else Vercel's production or preview), and after each
 // build gives bundles debug ids, uploads the maps and removes them from `.next`.
 import { join } from "node:path";
 import { detectRelease, processDirectory } from "../build/index.js";
 import { firstEnv } from "../core/env.js";
+export const keepServerMaps = (file) => !file.startsWith("static/");
 export function withBertha(config = {}, options = {}) {
     const c = config;
     const release = options.release ?? detectRelease();
+    const environment = firstEnv("BERTHA_ENVIRONMENT", "VERCEL_ENV");
     const previous = c.compiler?.runAfterProductionCompile;
     const next = {
         ...c,
         productionBrowserSourceMaps: true,
-        env: { ...c.env, ...(release ? { BERTHA_RELEASE: release } : {}) },
+        env: {
+            ...c.env,
+            ...(release ? { BERTHA_RELEASE: release } : {}),
+            ...(environment ? { BERTHA_ENVIRONMENT: environment } : {}),
+        },
         experimental: { ...c.experimental, serverSourceMaps: true },
         compiler: {
             ...c.compiler,
@@ -25,7 +32,7 @@ export function withBertha(config = {}, options = {}) {
                     release,
                     url: firstEnv("BERTHA_URL", "NEXT_PUBLIC_BERTHA_URL"),
                     uploadKey: firstEnv("BERTHA_UPLOAD_KEY"),
-                    keepMaps: options.keepMaps,
+                    keepMaps: options.keepMaps ?? keepServerMaps,
                     skip: ["cache", "standalone", "types"],
                     log: (m) => console.log(`[bertha] ${m}`),
                 }).catch((e) => console.warn(`[bertha] Source maps weren't processed: ${String(e)}`));

package/dist/node/index.js

@@ -25,7 +25,7 @@ export function init(options = {}) {
         key,
         url,
         release: options.release ?? firstEnv("BERTHA_RELEASE"),
-        environment: options.environment ?? firstEnv("BERTHA_ENVIRONMENT", "NODE_ENV"),
+        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()}` });
     setClient(client);

package/package.json

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