@voltro/plugin-sentry 0.60.0 → 0.61.0

package/CHANGELOG.md

@@ -39,6 +39,31 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.61.0] — 2026-08-31
+
+### ⚠ BREAKING
+
+- **@voltro/client, @voltro/web, @voltro/cli** — `RpcError.kind` now distinguishes transport, handler, client, and unknown failures; manually emitted events must add the field, while `useConnectionStatus` now degrades only for transport failures and clears on the next rpc success.
+
+  **`voltro update` carries you across this** — codemod `0.61.0/01_rpc_errors_have_kinds`. If you pin versions by hand and never run it, print the notes without changing anything: `voltro update --codemods-only --from <your current version> --dry-run` (this one ships in 0.61.0).
+- **@voltro/plugin-sentry, @voltro/cli** — Browser RPC spans now join the active page/navigation transaction and link to the Effect/server trace instead of creating one root transaction per call; `tracesSampleRate`, `browserTracing`, and the new `rpcSpans` switch control the resulting browser trace volume.
+
+  **`voltro update` carries you across this** — codemod `0.61.0/02_sentry_rpc_spans_join_page`. If you pin versions by hand and never run it, print the notes without changing anything: `voltro update --codemods-only --from <your current version> --dry-run` (this one ships in 0.61.0).
+
+### Fixed
+
+- **@voltro/cli** — **Six SSR failure sites report to Sentry, not three.**
+
+  0.60.0 gave the web server its own Sentry and wired the three loud sites: the SSR shell throw, the SPA layout shell throw, and the general render error (which covers a loader throw). The docs said "shell throw, loader throw, PPR/SWR refresh" — and an enumeration in a claim is read as exhaustive.
+
+  The other three were `warn`-level and reported to nobody: a failed PPR hole pass, a failed background SWR refresh, and a `not-found.tsx` that throws while rendering. They are quieter because the request still serves something — stale HTML, an unfilled hole, a plain 404 — which says something about the REQUEST and nothing about who else could find out. The answer to that is nobody: none of them reaches a browser boundary, so the pod's stdout was the only record.
+
+  They carry their own `voltro.stage` (`not-found-render`, `ppr-holes`, `swr-refresh`), so a quota-conscious project can drop them by stage without losing the three that fail the request.
+
+  `webSentry.test.ts` now fails if a render-path `log.error`/`log.warn` gains no reporter beside it — the property, rather than the six call sites.
+
+---
+
 ## [0.60.0] — 2026-08-31
 
 ### ⚠ BREAKING

package/README.md

@@ -2,7 +2,7 @@
 
 # @voltro/plugin-sentry
 
-**Deep Sentry integration — error tracking correlated to the distributed trace, breadcrumbs from the framework log sink, and (opt-in) performance traces routed from the framework's OTel tracer via @sentry/node in OTel-consumer mode. Errors carry the active trace_id + span_id + the request's recent log lines.**
+**Deep Sentry integration — trace-correlated error tracking, breadcrumbs from the framework log sink, page-owned browser performance spans, and server traces routed from the framework's OTel tracer via @sentry/node in OTel-consumer mode.**
 
 [📖 Documentation](https://docs.voltro.dev/docs/plugins/sentry) · [voltro.dev](https://voltro.dev) · [Voltro Cloud](https://voltro.cloud)
 

package/dist/index.d.ts

@@ -92,17 +92,9 @@ export declare interface SentryPluginOptions {
     /**
      * Route the framework's OTel spans to Sentry as transactions. Default **true**.
      *
-     * It was `false`, and that made the pair's default the worst of the three
-     * available. The BROWSER half defaults `tracesSampleRate: 1.0` with
-     * `browserTracing` on, so page loads, navigations and every rpc call already
-     * become spans without anybody asking. With the server side off, each of those
-     * spans is emitted and paid for, carries a `traceId` the api also logged, and
-     * belongs to a trace with no server half — a browser hop hanging off nothing.
-     * Both-off would at least be coherent; both-on is what the two halves were
-     * built for.
-     *
-     * `false` turns them off and still leaves errors + breadcrumbs, which is the
-     * whole of the plugin for an app with no trace budget.
+     * The browser half records page/navigation transactions and page-owned rpc
+     * child spans; those children link to the Effect/server trace. `false` turns
+     * server transactions off while leaving errors + breadcrumbs intact.
      */
     readonly traces?: boolean;
     /**

package/dist/index.js

@@ -120,7 +120,7 @@ var l = {
 	], T, E;
 	return s({
 		name: u,
-		description: "Deep Sentry integration — trace-correlated errors + breadcrumbs + (opt-in) performance traces.",
+		description: "Deep Sentry integration — trace-correlated errors, breadcrumbs, and controlled performance traces.",
 		permissions: w,
 		declaredEnv: g.declared,
 		interceptMutation: C,

package/dist/web.d.ts

@@ -38,21 +38,27 @@ export declare const isDeclaredRpcFailure: (event: {
     error: unknown;
 }) => boolean;
 
-/** Emit a browser-side Sentry span into the SAME trace as the server
- *  transaction the call will produce. */
+/** Add an rpc marker to the active page/navigation transaction and link it to
+ *  the Effect trace continued by the server. With no active browser parent,
+ *  `onlyIfParent` deliberately produces no recorded root transaction. */
 export declare const recordClientTraceSpan: (sentry: SentryBrowserLike, event: ClientTraceEvent) => void;
 
 export { reportClientError }
 
 export declare interface SentryBrowserLike {
-    continueTrace<T>(context: {
-        sentryTrace: string;
-        baggage?: string;
-    }, callback: () => T): T;
     startInactiveSpan(options: {
         name: string;
         op?: string;
+        onlyIfParent?: boolean;
         attributes?: Record<string, unknown>;
+        links?: ReadonlyArray<{
+            context: {
+                traceId: string;
+                spanId: string;
+                traceFlags: number;
+            };
+            attributes?: Record<string, string | number | boolean>;
+        }>;
     }): SentrySpanLike;
     withScope(callback: (scope: SentryBrowserScopeLike) => void): unknown;
     captureException(exception: unknown): unknown;
@@ -71,6 +77,12 @@ export declare interface SentryBrowserOptions {
     /** Instrument page loads + client navigations via `browserTracingIntegration`.
      *  Default true. */
     readonly browserTracing?: boolean;
+    /** Record rpc markers under the active page/navigation transaction and link
+     *  them to their server traces. Defaults to `browserTracing`; set `false` to
+     *  disable only this bridge while keeping browser error reporting. Set
+     *  `true` with `browserTracing:false` only when the app creates its own
+     *  active Sentry transactions. */
+    readonly rpcSpans?: boolean;
     /**
      * Whether a DECLARED failure that came back from an rpc call reaches Sentry.
      * **Default `false`**, matching `sentryPlugin({ captureFailures })`.
@@ -97,8 +109,4 @@ declare interface SentrySpanLike {
     end(): void;
 }
 
-/** Build the `sentry-trace` header for a client trace event (sampled=1 — the
- *  framework records always-on; Sentry's client applies its own sample rate). */
-export declare const sentryTraceHeader: (event: ClientTraceEvent) => string;
-
 export { }

package/dist/web.js

@@ -5,54 +5,66 @@ var i = (e, t) => {
 	e.withScope((n) => {
 		n.setTag("voltro.errorSource", t.source), t.pathname && n.setTag("route.pathname", t.pathname), t.componentStack && n.setContext("react", { componentStack: t.componentStack }), t.context && n.setContext("voltro", t.context), e.captureException(t.error);
 	});
-}, a = (e) => `${e.traceId}-${e.spanId}-1`, o = (e, t) => {
-	e.continueTrace({ sentryTrace: a(t) }, () => {
-		e.startInactiveSpan({
-			name: `${t.source}.${t.tag}`,
-			op: `rpc.client.${t.source}`,
-			attributes: {
-				"rpc.tag": t.tag,
-				"voltro.source": t.source
-			}
-		}).end();
-	});
-}, s = (e) => e.source.startsWith("rpc.") && typeof e.error?._tag == "string", c = (e) => {
+}, a = (e, t) => {
+	e.startInactiveSpan({
+		name: `${t.source}.${t.tag}`,
+		op: `rpc.client.${t.source}`,
+		onlyIfParent: !0,
+		attributes: {
+			"rpc.tag": t.tag,
+			"voltro.source": t.source
+		},
+		links: [{
+			context: {
+				traceId: t.traceId,
+				spanId: t.spanId,
+				traceFlags: 1
+			},
+			attributes: { "voltro.link.type": "rpc.server-trace" }
+		}]
+	}).end();
+}, o = (e) => e.source.startsWith("rpc.") && typeof e.error?._tag == "string", s = (e) => {
 	let t = r()[e];
 	return typeof t == "string" && t !== "" ? t : void 0;
-}, l, u, d = async (e = {}) => {
+}, c, l, u = async (e = {}) => {
 	if (typeof window > "u") return;
-	let r = e.dsn ?? c("VOLTRO_PUBLIC_SENTRY_DSN");
+	let r = e.dsn ?? s("VOLTRO_PUBLIC_SENTRY_DSN");
 	if (!r) return;
-	let a = e.environment ?? c("VOLTRO_PUBLIC_SENTRY_ENVIRONMENT"), d = e.release ?? c("VOLTRO_PUBLIC_SENTRY_RELEASE"), p = await import("@sentry/react");
-	p.init({
+	let u = e.environment ?? s("VOLTRO_PUBLIC_SENTRY_ENVIRONMENT"), f = e.release ?? s("VOLTRO_PUBLIC_SENTRY_RELEASE"), p = e.tracesSampleRate ?? 1, m = e.browserTracing !== !1, h = e.rpcSpans ?? m, g = await import("@sentry/react");
+	g.init({
 		dsn: r,
-		tracesSampleRate: e.tracesSampleRate ?? 1,
-		...a ? { environment: a } : {},
-		...d ? { release: d } : {},
-		integrations: e.browserTracing === !1 ? [] : [p.browserTracingIntegration()]
+		tracesSampleRate: p,
+		...u ? { environment: u } : {},
+		...f ? { release: f } : {},
+		integrations: m ? [g.browserTracingIntegration()] : []
 	});
-	let m = p;
-	l?.(), l = n((e) => {
+	let _ = g;
+	c?.(), c = void 0, h && (c = n((e) => {
 		try {
-			o(m, e);
+			a(_, e);
 		} catch {}
-	}), u?.();
-	let h = e.captureFailures ?? !1;
-	u = t((e) => {
+	})), l?.();
+	let v = e.captureFailures ?? !1;
+	l = t((e) => {
 		try {
-			if (s(e) && !f(e.error, h)) return;
-			i(m, e);
+			if (o(e) && !d(e.error, v)) return;
+			i(_, e);
 		} catch {}
+	}), console.info("[@voltro/plugin-sentry] browser active", {
+		tracesSampleRate: p,
+		browserTracing: m,
+		rpcSpans: h,
+		rpcSpanMode: h ? "page-child-with-server-link" : "off"
 	});
-}, f = (e, t) => {
+}, d = (e, t) => {
 	if (typeof t != "function") return t;
 	try {
 		return t(e);
 	} catch {
 		return !0;
 	}
-}, p = () => {
-	l?.(), l = void 0, u?.(), u = void 0;
+}, f = () => {
+	c?.(), c = void 0, l?.(), l = void 0;
 };
 //#endregion
-export { i as captureClientError, p as closeSentryBrowser, d as initSentryBrowser, s as isDeclaredRpcFailure, o as recordClientTraceSpan, e as reportClientError, a as sentryTraceHeader };
+export { i as captureClientError, f as closeSentryBrowser, u as initSentryBrowser, o as isDeclaredRpcFailure, a as recordClientTraceSpan, e as reportClientError };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@voltro/plugin-sentry",
-  "version": "0.60.0",
-  "description": "Deep Sentry integration — error tracking correlated to the distributed trace, breadcrumbs from the framework log sink, and (opt-in) performance traces routed from the framework's OTel tracer via @sentry/node in OTel-consumer mode. Errors carry the active trace_id + span_id + the request's recent log lines.",
+  "version": "0.61.0",
+  "description": "Deep Sentry integration — error tracking correlated to distributed traces, breadcrumbs from the framework log sink, controlled browser performance spans, and server traces routed from the framework's OTel tracer via @sentry/node in OTel-consumer mode.",
   "keywords": [
     "voltro",
     "typescript",
@@ -43,10 +43,10 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/client": "0.60.0",
-    "@voltro/env": "0.60.0",
-    "@voltro/logger": "0.60.0",
-    "@voltro/protocol": "0.60.0"
+    "@voltro/client": "0.61.0",
+    "@voltro/env": "0.61.0",
+    "@voltro/logger": "0.61.0",
+    "@voltro/protocol": "0.61.0"
   },
   "optionalDependencies": {
     "@sentry/node": "^10.70.0",