@rangojs/router 0.0.0-experimental.130 → 0.0.0-experimental.131

package/dist/vite/index.js

@@ -2133,7 +2133,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.130",
+  version: "0.0.0-experimental.131",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rangojs/router",
-  "version": "0.0.0-experimental.130",
+  "version": "0.0.0-experimental.131",
   "description": "Django-inspired RSC router with composable URL patterns",
   "keywords": [
     "react",

package/src/router/instrument.ts

@@ -231,26 +231,46 @@ export function observePhase<T>(
   // Neither surface active: direct call, zero overhead.
   if (!store && !tracing) return fn(NOOP_TRACE_SPAN);
 
-  // Attributes only land on a real span, so skip the wrapper when only the perf
-  // surface is active (traceSpan would apply them to NOOP_TRACE_SPAN for nothing).
-  // `lazyAttributes` resolve AFTER fn runs (e.g. rango.route, known post-match).
+  // Attributes only land on a real span. Build the attribute/lazy wrapper only
+  // when this phase's span is actually enabled (not toggled off via `spans`), and
+  // short-circuit inside when the runner hands back the no-op span (tracing
+  // configured but off at runtime — e.g. no executionContext.tracing). That keeps
+  // the "configured but effectively off" path free of per-call attribute loops
+  // and lazy `.then()` allocations. `lazyAttributes` resolve AFTER fn runs (e.g.
+  // rango.route, known post-match) and apply on BOTH success and failure so an
+  // errored phase span is still tagged.
   const attributes = spec.attributes;
   const lazy = spec.lazyAttributes;
+  const spanEnabled =
+    tracing !== undefined && tracing.phases[spec.tracePhase] !== false;
   const wrapped: (span: TraceSpan) => T =
-    (attributes || lazy) && tracing
+    (attributes || lazy) && spanEnabled
       ? (span) => {
+          if (span === NOOP_TRACE_SPAN) return fn(span);
           if (attributes) applyAttributes(span, attributes);
+          // A SYNCHRONOUS throw from fn skips applyLate — fine by design: the only
+          // lazyAttributes phase (render) is always async, so any internal throw
+          // surfaces as a rejection that the onReject branch below DOES tag. If a
+          // sync lazyAttributes phase is ever added, wrap this in try/catch.
           const out = fn(span);
           if (!lazy) return out;
+          const applyLate = () => {
+            const late = lazy();
+            if (late) applyAttributes(span, late);
+          };
           if (out instanceof Promise) {
-            return out.then((value) => {
-              const late = lazy();
-              if (late) applyAttributes(span, late);
-              return value;
-            }) as T;
+            return out.then(
+              (value) => {
+                applyLate();
+                return value;
+              },
+              (error) => {
+                applyLate();
+                throw error;
+              },
+            ) as T;
           }
-          const late = lazy();
-          if (late) applyAttributes(span, late);
+          applyLate();
           return out;
         }
       : fn;
@@ -269,6 +289,24 @@ export function observePhase<T>(
   return runThenSettle(runSpan, () => recordPhaseMetric(store, metric, start));
 }
 
+/**
+ * Open a rango.handler span around one segment route/layout handler call. The
+ * segment-resolution hot path runs this PER SEGMENT, so it checks the
+ * perf/tracing surface FIRST and calls the handler directly when neither is
+ * active — building neither the PhaseSpec (PHASES.handler allocates) nor the
+ * wrapper closure on the off path. The handler:<id> perf metric is owned by the
+ * track() at the call site, so this is span-only (metric:false).
+ */
+export function observeHandler<C, R>(
+  id: string,
+  handler: (ctx: C) => R,
+  ctx: C,
+): R {
+  const reqCtx = _getRequestContext();
+  if (!reqCtx?._metricsStore && !reqCtx?._tracing) return handler(ctx);
+  return observePhase(PHASES.handler(id), () => handler(ctx));
+}
+
 /**
  * Emit one discrete telemetry event (the event-shaped counterpart to
  * observePhase). Resolves the sink from the active router context and stamps the

package/src/router/segment-resolution/fresh.ts

@@ -30,7 +30,7 @@ import {
 import { applyViewTransitionDefault } from "./view-transition-default.js";
 import { getRouterContext } from "../router-context.js";
 import { observeStreamedHandler } from "./streamed-handler-telemetry.js";
-import { observePhase, PHASES } from "../instrument.js";
+import { observeHandler } from "../instrument.js";
 import {
   track,
   RangoContext,
@@ -260,7 +260,7 @@ export async function resolveSegment<TEnv>(
       const doneRouteHandler = track(`handler:${entry.id}`, 2);
       if (entry.loading) {
         const result = handleHandlerResult(
-          observePhase(PHASES.handler(entry.id), () => handler(context)),
+          observeHandler(entry.id, handler, context),
         );
         if (result instanceof Promise) {
           warnOnStreamedResponse(result, entry.id);
@@ -284,7 +284,7 @@ export async function resolveSegment<TEnv>(
         }
       } else {
         component = handleHandlerResult(
-          await observePhase(PHASES.handler(entry.id), () => handler(context)),
+          await observeHandler(entry.id, handler, context),
         );
         doneRouteHandler();
       }
@@ -511,9 +511,7 @@ export async function resolveParallelEntry<TEnv>(
       if (hasLoadingFallback) {
         const result =
           typeof handler === "function"
-            ? observePhase(PHASES.handler(`${parallelEntry.id}.${slot}`), () =>
-                handler(context),
-              )
+            ? observeHandler(`${parallelEntry.id}.${slot}`, handler, context)
             : handler;
         if (result instanceof Promise) {
           result.finally(doneParallelHandler).catch(() => {});
@@ -537,9 +535,10 @@ export async function resolveParallelEntry<TEnv>(
       } else {
         component =
           typeof handler === "function"
-            ? await observePhase(
-                PHASES.handler(`${parallelEntry.id}.${slot}`),
-                () => handler(context),
+            ? await observeHandler(
+                `${parallelEntry.id}.${slot}`,
+                handler,
+                context,
               )
             : handler;
         doneParallelHandler();

package/src/router/segment-resolution/helpers.ts

@@ -23,7 +23,7 @@ import type { ResolvedSegment, ErrorInfo, HandlerContext } from "../../types";
 import type { SegmentResolutionDeps } from "../types.js";
 import { debugLog } from "../logging.js";
 import { tryStaticLookup } from "./static-store.js";
-import { observePhase, PHASES } from "../instrument.js";
+import { observeHandler } from "../instrument.js";
 import type { TelemetrySink } from "../telemetry.js";
 import { resolveSink, safeEmit, getRequestId } from "../telemetry.js";
 
@@ -131,15 +131,16 @@ export async function resolveLayoutComponent<TEnv>(
   entry: EntryData,
   context: HandlerContext<any, TEnv>,
 ): Promise<ReactNode> {
-  // rango.handler span for this layout/cache handler (the perf metric is owned
-  // by the track("handler:<id>") at the call site; this adds the span only).
-  return observePhase(PHASES.handler(entry.id), async () => {
-    const component = await tryStaticHandler(entry, entry.shortCode);
-    if (component !== undefined) return component;
-    return typeof entry.handler === "function"
-      ? handleHandlerResult(await entry.handler(context))
-      : (entry.handler as ReactNode);
-  });
+  // Static/prerender hit: no handler runs, so emit no rango.handler span.
+  const staticComponent = await tryStaticHandler(entry, entry.shortCode);
+  if (staticComponent !== undefined) return staticComponent;
+  const handler = entry.handler;
+  if (typeof handler !== "function") return handler as ReactNode;
+  // Wrap ONLY the handler call in the rango.handler span (the perf metric is owned
+  // by track("handler:<id>") at the call site). handleHandlerResult stays OUTSIDE
+  // the span so a handler that returns a Response (redirect control flow, which it
+  // rethrows) is not recorded as a span error — mirrors the route-handler sites.
+  return handleHandlerResult(await observeHandler(entry.id, handler, context));
 }
 
 // ---------------------------------------------------------------------------

package/src/router/segment-resolution/revalidation.ts

@@ -43,7 +43,7 @@ import {
 } from "./helpers.js";
 import { applyViewTransitionDefault } from "./view-transition-default.js";
 import { getRouterContext } from "../router-context.js";
-import { observeEvent, observePhase, PHASES } from "../instrument.js";
+import { observeEvent, observeHandler } from "../instrument.js";
 import { observeStreamedHandler } from "./streamed-handler-telemetry.js";
 import {
   track,
@@ -794,14 +794,14 @@ export async function resolveEntryHandlerWithRevalidation<TEnv>(
           : routeEntry.handler;
       if (!routeEntry.loading) {
         const result = handleHandlerResult(
-          await observePhase(PHASES.handler(entry.id), () => handler(context)),
+          await observeHandler(entry.id, handler, context),
         );
         doneHandler();
         return result;
       }
       if (!actionContext) {
         const result = handleHandlerResult(
-          observePhase(PHASES.handler(entry.id), () => handler(context)),
+          observeHandler(entry.id, handler, context),
         );
         if (result instanceof Promise) {
           warnOnStreamedResponse(result, routeEntry.id);
@@ -827,7 +827,7 @@ export async function resolveEntryHandlerWithRevalidation<TEnv>(
         entryId: entry.id,
       });
       const actionResult = handleHandlerResult(
-        await observePhase(PHASES.handler(entry.id), () => handler(context)),
+        await observeHandler(entry.id, handler, context),
       );
       doneHandler();
       return {