@timber-js/app 0.2.0-alpha.7 → 0.2.0-alpha.71

package/src/server/logger.ts

@@ -1,16 +1,15 @@
 /**
  * Logger — structured logging with environment-aware formatting.
  *
- * timber.js does not ship a logger. Users export any object with
- * info/warn/error/debug methods from instrumentation.ts and the framework
- * picks it up. Silent if no logger export is present.
+ * timber.js ships a DefaultLogger that writes human-readable lines to stderr
+ * in production. Users can export a custom logger from instrumentation.ts to
+ * replace it with pino, winston, or any TimberLogger-compatible object.
  *
  * See design/17-logging.md §"Production Logging"
  */
 
 import { getTraceStore } from './tracing.js';
-import { formatSsrError } from './error-formatter.js';
-import { isDebug } from './debug.js';
+import { createDefaultLogger } from './default-logger.js';
 
 // ─── Logger Interface ─────────────────────────────────────────────────────
 
@@ -24,21 +23,24 @@ export interface TimberLogger {
 
 // ─── Logger Registry ──────────────────────────────────────────────────────
 
-let _logger: TimberLogger | null = null;
+// Initialize with DefaultLogger so production errors are never silent.
+// Replaced when setLogger() is called from instrumentation.ts.
+let _logger: TimberLogger = createDefaultLogger();
 
 /**
  * Set the user-provided logger. Called by the instrumentation loader
- * when it finds a `logger` export in instrumentation.ts.
+ * when it finds a `logger` export in instrumentation.ts. Replaces
+ * the DefaultLogger entirely.
  */
 export function setLogger(logger: TimberLogger): void {
   _logger = logger;
 }
 
 /**
- * Get the current logger, or null if none configured.
- * Framework-internal — used at framework event points to emit structured logs.
+ * Get the current logger. Always non-null — returns DefaultLogger when
+ * no custom logger is configured.
  */
-export function getLogger(): TimberLogger | null {
+export function getLogger(): TimberLogger {
   return _logger;
 }
 
@@ -71,12 +73,12 @@ export function logRequestCompleted(data: {
   /** Number of concurrent in-flight requests (including this one) at completion time. */
   concurrency?: number;
 }): void {
-  _logger?.info('request completed', withTraceContext(data));
+  _logger.info('request completed', withTraceContext(data));
 }
 
 /** Log request received. Level: debug. */
 export function logRequestReceived(data: { method: string; path: string }): void {
-  _logger?.debug('request received', withTraceContext(data));
+  _logger.debug('request received', withTraceContext(data));
 }
 
 /** Log a slow request warning. Level: warn. */
@@ -88,7 +90,7 @@ export function logSlowRequest(data: {
   /** Number of concurrent in-flight requests at the time the slow request completed. */
   concurrency?: number;
 }): void {
-  _logger?.warn('slow request exceeded threshold', withTraceContext(data));
+  _logger.warn('slow request exceeded threshold', withTraceContext(data));
 }
 
 /** Log middleware short-circuit. Level: debug. */
@@ -97,54 +99,60 @@ export function logMiddlewareShortCircuit(data: {
   path: string;
   status: number;
 }): void {
-  _logger?.debug('middleware short-circuited', withTraceContext(data));
+  _logger.debug('middleware short-circuited', withTraceContext(data));
 }
 
 /** Log unhandled error in middleware phase. Level: error. */
 export function logMiddlewareError(data: { method: string; path: string; error: unknown }): void {
-  if (_logger) {
-    _logger.error('unhandled error in middleware phase', withTraceContext(data));
-  } else if (isDebug()) {
-    console.error('[timber] middleware error', data.error);
-  }
+  _logger.error('unhandled error in middleware phase', withTraceContext(data));
 }
 
 /** Log unhandled render-phase error. Level: error. */
-export function logRenderError(data: { method: string; path: string; error: unknown }): void {
-  if (_logger) {
-    _logger.error('unhandled render-phase error', withTraceContext(data));
-  } else if (isDebug()) {
-    // No logger configured — fall back to console.error in dev with
-    // cleaned-up error messages (vendor paths rewritten, hints added).
-    console.error('[timber] render error:', formatSsrError(data.error));
-  }
+export function logRenderError(data: {
+  method: string;
+  path: string;
+  error: unknown;
+  errorId?: string;
+}): void {
+  _logger.error('unhandled render-phase error', withTraceContext(data));
 }
 
 /** Log proxy.ts uncaught error. Level: error. */
 export function logProxyError(data: { error: unknown }): void {
-  if (_logger) {
-    _logger.error('proxy.ts threw uncaught error', withTraceContext(data));
-  } else if (isDebug()) {
-    console.error('[timber] proxy error', data.error);
-  }
+  _logger.error('proxy.ts threw uncaught error', withTraceContext(data));
+}
+
+/** Log unhandled error in server action. Level: error. */
+export function logActionError(data: { method: string; path: string; error: unknown }): void {
+  _logger.error('unhandled server action error', withTraceContext(data));
+}
+
+/** Log unhandled error in route handler. Level: error. */
+export function logRouteError(data: { method: string; path: string; error: unknown }): void {
+  _logger.error('unhandled route handler error', withTraceContext(data));
+}
+
+/** Log SSR streaming error (post-shell). Level: error. */
+export function logStreamingError(data: { error: unknown }): void {
+  _logger.error('SSR streaming error (post-shell)', withTraceContext(data));
 }
 
 /** Log waitUntil() adapter missing (once at startup). Level: warn. */
 export function logWaitUntilUnsupported(): void {
-  _logger?.warn('adapter does not support waitUntil()');
+  _logger.warn('adapter does not support waitUntil()');
 }
 
 /** Log waitUntil() promise rejection. Level: warn. */
 export function logWaitUntilRejected(data: { error: unknown }): void {
-  _logger?.warn('waitUntil() promise rejected', withTraceContext(data));
+  _logger.warn('waitUntil() promise rejected', withTraceContext(data));
 }
 
 /** Log staleWhileRevalidate refetch failure. Level: warn. */
 export function logSwrRefetchFailed(data: { cacheKey: string; error: unknown }): void {
-  _logger?.warn('staleWhileRevalidate refetch failed', withTraceContext(data));
+  _logger.warn('staleWhileRevalidate refetch failed', withTraceContext(data));
 }
 
 /** Log cache miss. Level: debug. */
 export function logCacheMiss(data: { cacheKey: string }): void {
-  _logger?.debug('timber.cache MISS', withTraceContext(data));
+  _logger.debug('timber.cache MISS', withTraceContext(data));
 }

package/src/server/middleware-runner.ts

@@ -1,9 +1,9 @@
 /**
- * Middleware runner — executes a route's middleware.ts before rendering.
+ * Middleware runner — executes a route's middleware.ts chain before rendering.
  *
- * Only the leaf route's middleware runs. There is no middleware chain.
- * Middleware does NOT have next() — it either short-circuits with a Response
- * or returns void to continue to access checks + render.
+ * All middleware.ts files in the segment chain run, root to leaf (top-down).
+ * The first middleware that returns a Response short-circuits the chain.
+ * There is no next() — each middleware is independent.
  *
  * See design/07-routing.md §"middleware.ts"
  */
@@ -30,3 +30,30 @@ export async function runMiddleware(
   }
   return undefined;
 }
+
+/**
+ * Run all middleware functions in the segment chain, root to leaf.
+ *
+ * Execution is top-down: root middleware runs first, leaf middleware runs last.
+ * All middleware share the same MiddlewareContext — a parent that sets
+ * ctx.requestHeaders makes it visible to child middleware and downstream components.
+ *
+ * Short-circuits on the first middleware that returns a Response.
+ * Remaining middleware in the chain do not execute.
+ *
+ * @param chain - Middleware functions ordered root-to-leaf
+ * @param ctx - Shared middleware context
+ * @returns A Response if any middleware short-circuited, or undefined to continue
+ */
+export async function runMiddlewareChain(
+  chain: MiddlewareFn[],
+  ctx: MiddlewareContext
+): Promise<Response | undefined> {
+  for (const fn of chain) {
+    const result = await fn(ctx);
+    if (result instanceof Response) {
+      return result;
+    }
+  }
+  return undefined;
+}