vibe-gx 4.1.0 → 4.1.2

package/README.md

@@ -46,7 +46,7 @@ npm install vibe-gx
 | :---------------------------- | :--------------------------------------------------------- |
 | 🚀 **Code-Gen Serialization** | Schema-compiled JSON serializers via `new Function()`      |
 | 🎯 **Hybrid Router**          | O(1) static + O(log n) Trie routing                        |
-| 🔌 **Plugin System**          | Fastify-style `register()` with encapsulation              |
+| 🔌 **Plugin System**          | Encapsulated `register()` with optional route prefixes     |
 | 🎨 **Decorators**             | Extend app, request, and response                          |
 | ⚡ **Cluster Mode**           | Built-in multi-process scaling                             |
 | 💾 **LRU Cache**              | Built-in response caching with ETag                        |
@@ -133,7 +133,52 @@ app.post("/users", (req) => {
 
 ---
 
-## 🔌 Plugins (Fastify-style)
+## 📝 Logging & Error Handling
+
+Vibe ships with a structured JSON logger (Pino-compatible) and a powerful error interception system. Errors thrown, returned, or sent from any route are automatically caught and routed through a central error handler.
+
+### JSON Structured Logging
+
+Initialize the app with `logger: { lifecycle: true }` or add `prettyPrint: true` for development to get beautiful, human-readable terminal output.
+
+```javascript
+const app = vibe({
+  logger: {
+    lifecycle: true,
+    prettyPrint: process.env.NODE_ENV !== "production",
+  },
+});
+
+// JSON native bindings
+app.log.info({ database: "online" }, "System booting...");
+```
+
+### Contextual Sub-Loggers
+
+Every incoming request dynamically extracts a fast UUID exposed securely on `req.id` natively piping through to `req.log`.
+
+```javascript
+app.get("/users/:id", (req) => {
+  req.log.warn("Database lookup constraint fired");
+  // Production Output -> {"level":40,"time":123,"reqId":"abcd-123", "msg":"..."}
+
+  return { success: true };
+});
+```
+
+### Central Error Abstraction
+
+To route an error into the central handler without halting execution via `throw`, simply return an `Error` object from your handler — Vibe intercepts it automatically:
+
+```javascript
+app.get("/test", (req, res) => {
+  return new Error("Something went wrong");
+});
+```
+
+---
+
+## 🔌 Plugin System
 
 Plugins provide encapsulated route groups with optional prefixes:
 
@@ -215,13 +260,13 @@ Extend app, request, or response with custom properties:
 // App decorator - shared config
 app.decorate("config", { env: "production", version: "1.0.0" });
 
-// Access via app.decorators in main app
-app.get("/version", () => ({ version: app.decorators.config.version }));
+// Access directly on the app
+app.get("/version", () => ({ version: app.config.version }));
 
-// In plugins, decorators are spread directly (no .decorators)
+// Same in plugins — decorators are spread directly
 app.register(
   async (api) => {
-    api.get("/env", () => ({ env: api.config.env })); // Direct access
+    api.get("/env", () => ({ env: api.config.env }));
   },
   { prefix: "/api" },
 );
@@ -541,22 +586,26 @@ app.post(
 
 ### Application
 
-| Method                                           | Description          |
-| :----------------------------------------------- | :------------------- |
-| `app.get/post/put/del/patch/head(path, handler)` | Register route       |
-| `app.listen(port, host?, callback?)`             | Start server         |
-| `app.register(fn, { prefix })`                   | Register plugin      |
-| `app.plugin(fn)`                                 | Global interceptor   |
-| `app.decorate(name, value)`                      | Add app property     |
-| `app.decorateRequest(name, value)`               | Add to all requests  |
-| `app.decorateReply(name, value)`                 | Add to all responses |
-| `app.setPublicFolder(path)`                      | Set static folder    |
-| `app.logRoutes()`                                | Log all routes       |
+| Method                                           | Description            |
+| :----------------------------------------------- | :--------------------- |
+| `vibe({ logger?: LoggerConfig })`                | Initialize app         |
+| `app.setErrorHandler(fn)`                        | Override error handler |
+| `app.get/post/put/del/patch/head(path, handler)` | Register route         |
+| `app.listen(port, host?, callback?)`             | Start server           |
+| `app.register(fn, { prefix })`                   | Register plugin        |
+| `app.plugin(fn)`                                 | Global interceptor     |
+| `app.decorate(name, value)`                      | Add app property       |
+| `app.decorateRequest(name, value)`               | Add to all requests    |
+| `app.decorateReply(name, value)`                 | Add to all responses   |
+| `app.setPublicFolder(path)`                      | Set static folder      |
+| `app.logRoutes()`                                | Log all routes         |
 
 ### Request (`req`)
 
 | Property      | Description                |
 | :------------ | :------------------------- |
+| `req.id`      | Auto-generated UUID logic  |
+| `req.log`     | Context-bound logger API   |
 | `req.params`  | Route parameters (`:id`)   |
 | `req.query`   | Query string (`?page=1`)   |
 | `req.body`    | Parsed JSON/form body      |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-gx",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "description": "A lightweight, high-performance Node.js web framework.",
   "type": "module",
   "main": "vibe.js",

package/utils/core/handler.js

@@ -142,11 +142,16 @@ export function handleError(error, req, res) {
   const isDev = process.env.NODE_ENV !== "production";
   const message = error.message || "Unknown error";
 
-  // Log error (full stack in dev, message only in production)
-  if (isDev) {
-    console.error("[VIBE ERROR]:", error);
+  // Log error using context-aware structured logger if available
+  if (req && req.log) {
+    req.log.error(error);
   } else {
-    console.error("[VIBE ERROR]:", message);
+    // Fallback: full stack in dev, message only in production
+    if (isDev) {
+      console.error("[VIBE ERROR]:", error);
+    } else {
+      console.error("[VIBE ERROR]:", message);
+    }
   }
 
   if (!res.headersSent) {

package/utils/core/logger.js

@@ -0,0 +1,185 @@
+import os from "os";
+import fs from "fs";
+import { color } from "../helpers/colors.js";
+
+const LOG_LEVELS = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60,
+};
+
+const LEVEL_NAMES = {
+  10: "TRACE",
+  20: "DEBUG",
+  30: "INFO",
+  40: "WARN",
+  50: "ERROR",
+  60: "FATAL",
+};
+
+/**
+ * High-performance structured JSON logger (Fastify/Pino style).
+ */
+export class Logger {
+  constructor(options = {}) {
+    this.level = LOG_LEVELS[options.level || "info"] || 30;
+    this.colors = options.colors !== undefined ? options.colors : true;
+    this.prettyPrint =
+      options.prettyPrint !== undefined ? options.prettyPrint : this.colors;
+    this.lifecycle = options.lifecycle || false;
+    this.stream = options.stream || process.stdout;
+    this.dest = options.dest || "console"; // "console", "file", "both"
+    this.logFile = options.logFile;
+    this.bindings = options.bindings || {};
+
+    // Initialize file stream if needed
+    if (this.logFile && (this.dest === "file" || this.dest === "both")) {
+      this.fileStream = fs.createWriteStream(this.logFile, { flags: "a" });
+    }
+
+    if (!this.bindings.pid) this.bindings.pid = process.pid;
+    if (!this.bindings.hostname) this.bindings.hostname = os.hostname();
+  }
+
+  /**
+   * Creates a sub-logger with scoped bindings (e.g. reqId).
+   */
+  child(bindings) {
+    return new Logger({
+      level: Object.keys(LOG_LEVELS).find(
+        (key) => LOG_LEVELS[key] === this.level,
+      ),
+      colors: this.colors,
+      prettyPrint: this.prettyPrint,
+      lifecycle: this.lifecycle,
+      stream: this.stream,
+      dest: this.dest,
+      logFile: this.logFile,
+      bindings: { ...this.bindings, ...bindings },
+    });
+  }
+
+  trace(obj, msg, c) {
+    this._log(10, obj, msg, c);
+  }
+  debug(obj, msg, c) {
+    this._log(20, obj, msg, c);
+  }
+  info(obj, msg, c) {
+    this._log(30, obj, msg, c);
+  }
+  warn(obj, msg, c) {
+    this._log(40, obj, msg, c);
+  }
+  error(obj, msg, c) {
+    this._log(50, obj, msg, c);
+  }
+  fatal(obj, msg, c) {
+    this._log(60, obj, msg, c);
+  }
+
+  _log(level, obj, msg, c) {
+    if (level < this.level) return;
+
+    const base = {
+      level,
+      time: Date.now(),
+      ...this.bindings,
+    };
+
+    let logData = {};
+    let customColor = undefined;
+
+    if (obj instanceof Error) {
+      logData.err = {
+        type: obj.name || "Error",
+        message: obj.message,
+        stack: obj.stack,
+      };
+      if (typeof msg === "string") logData.msg = msg;
+      else logData.msg = obj.message;
+      if (typeof c === "string") customColor = c;
+    } else if (typeof obj === "string") {
+      logData.msg = obj;
+      if (typeof msg === "string") customColor = msg;
+    } else if (typeof obj === "object" && obj !== null) {
+      logData = { ...obj };
+      if (typeof msg === "string") logData.msg = msg;
+      if (typeof c === "string") customColor = c;
+    } else {
+      logData.msg = String(obj);
+      if (typeof msg === "string") customColor = msg;
+    }
+
+    if (customColor) {
+      logData.color = customColor;
+    }
+
+    const finalLog = { ...base, ...logData };
+
+    if (this.dest === "console" || this.dest === "both") {
+      if (this.prettyPrint) {
+        this._printPretty(finalLog);
+      } else {
+        this.stream.write(JSON.stringify(finalLog) + "\n");
+      }
+    }
+
+    if ((this.dest === "file" || this.dest === "both") && this.fileStream) {
+      this.fileStream.write(JSON.stringify(finalLog) + "\n");
+    }
+  }
+
+  _printPretty(log) {
+    const time = new Date(log.time).toLocaleTimeString();
+    const lvlName = LEVEL_NAMES[log.level] || "INFO";
+    let prefixC = color.cyan;
+    if (log.level >= 50) prefixC = color.red;
+    else if (log.level === 40) prefixC = color.yellow;
+    else if (log.level <= 20) prefixC = color.dim;
+
+    const prefix = prefixC(`[VIBE ${lvlName} ${time}]`);
+    let context = "";
+    if (log.reqId) {
+      context = `\x1b[90m[${log.reqId}]\x1b[0m `;
+    }
+
+    let content = log.msg || "";
+    if (log.color && color[log.color]) {
+      content = color[log.color](content);
+    }
+
+    if (log.err && log.err.stack) {
+      content += "\n" + prefixC(log.err.stack);
+    }
+
+    // Attempt to print remaining metadata if it's not standard
+    const skipKeys = [
+      "level",
+      "time",
+      "pid",
+      "hostname",
+      "reqId",
+      "msg",
+      "err",
+      "color",
+    ];
+    let metaStr = "";
+    for (const key of Object.keys(log)) {
+      if (!skipKeys.includes(key)) {
+        metaStr += ` \x1b[90m${key}=${JSON.stringify(log[key])}\x1b[0m`;
+      }
+    }
+
+    this.stream.write(`${prefix} ${context}${content}${metaStr}\n`);
+  }
+}
+
+export function createLogger(options = {}) {
+  return new Logger(options);
+}
+
+export default createLogger;

package/utils/core/response.js

@@ -35,6 +35,10 @@ const vibeResponseMethods = {
       throw new Error("Response data is not a sendable data type");
     }
 
+    if (data instanceof Error) {
+      return this._vibeOptions.errorHandler(data, this.req, this);
+    }
+
     if (typeof data === "object" && data !== null) {
       if (!this.headersSent) this.writeHead(this.statusCode || 200, JSON_CT);
       this.end(JSON.stringify(data));
@@ -50,6 +54,9 @@ const vibeResponseMethods = {
    * @param {Object} data
    */
   json(data) {
+    if (data instanceof Error) {
+      return this._vibeOptions.errorHandler(data, this.req, this);
+    }
     if (!this.headersSent) this.writeHead(this.statusCode || 200, JSON_CT);
     this.end(JSON.stringify(data));
   },

package/utils/core/server.js

@@ -1,8 +1,8 @@
 import http from "http";
+import crypto from "crypto";
 import { error, getNetworkIP, handleError, isSendAble } from "./handler.js";
 import bodyParser from "./parser.js";
 import { installResponseMethods, initResponse } from "./response.js";
-import dns from "node:dns/promises";
 import { parseQuery } from "../native.js";
 
 // Pre-allocated headers (frozen for V8 optimization)
@@ -90,6 +90,33 @@ async function server(options, port, host, callback) {
 
   // Main request handler - ULTRA OPTIMIZED
   function reqListener(req, res) {
+    req.id = crypto.randomUUID();
+    req.log = options.logger.child({ reqId: req.id });
+
+    if (options.loggerConfig && options.loggerConfig.lifecycle) {
+      req.startTime = Date.now();
+
+      // Determine sender IP early for logging
+      const sender =
+        req.socket.remoteAddress || req.headers["x-forwarded-for"] || "unknown";
+
+      req.log.info(
+        { type: "req", url: req.url, method: req.method, sender },
+        "Incoming request",
+      );
+
+      res.on("finish", () => {
+        req.log.info(
+          {
+            type: "res",
+            statusCode: res.statusCode,
+            responseTimeMs: Date.now() - req.startTime,
+          },
+          "Request completed",
+        );
+      });
+    }
+
     // Fast pathname extraction
     const url = req.url;
     const qIdx = url.indexOf("?");
@@ -151,13 +178,19 @@ async function server(options, port, host, callback) {
             if (result && typeof result.then === "function") {
               result
                 .then((val) => {
+                  if (val instanceof Error) {
+                    return options.errorHandler(val, req, res);
+                  }
                   if (val !== undefined && !res.writableEnded) {
                     res.writeHead(200, JSON_HEADERS);
                     res.end(serialize ? serialize(val) : JSON.stringify(val));
                   }
                 })
-                .catch((err) => handleError(err, req, res));
+                .catch((err) => options.errorHandler(err, req, res));
             } else if (typeof result === "object" && result !== null) {
+              if (result instanceof Error) {
+                return options.errorHandler(result, req, res);
+              }
               res.writeHead(200, JSON_HEADERS);
               res.end(serialize ? serialize(result) : JSON.stringify(result));
             } else {
@@ -166,7 +199,7 @@ async function server(options, port, host, callback) {
             }
           }
         } catch (err) {
-          handleError(err, req, res);
+          options.errorHandler(err, req, res);
         }
         return;
       }
@@ -226,6 +259,9 @@ async function server(options, port, host, callback) {
       // Execute handler
       if (typeof handler === "function") {
         const result = await handler(req, res);
+        if (result instanceof Error) {
+          return options.errorHandler(result, req, res);
+        }
         if (result !== undefined && !res.writableEnded) {
           if (serialize) {
             // Pre-compiled schema serializer — fastest path
@@ -247,7 +283,7 @@ async function server(options, port, host, callback) {
         throw new Error("Invalid handler type");
       }
     } catch (err) {
-      handleError(err, req, res);
+      options.errorHandler(err, req, res);
     }
   }
 
@@ -256,10 +292,7 @@ async function server(options, port, host, callback) {
 
   const vibe_server = http.createServer(reqListener);
 
-  vibe_server.listen(port, mainHost, async () => {
-    try {
-      await dns.lookup("::", { all: true });
-    } catch {}
+  vibe_server.listen(port, mainHost, () => {
     getNetworkIP(mainHost, port);
 
     const strategy = useTrieMatching ? "Trie (O(log n))" : "Linear (O(n))";
@@ -271,7 +304,29 @@ async function server(options, port, host, callback) {
   });
 
   vibe_server.on("error", (err) => {
-    error(`Port ${port} is already in use! \n${err.message}`);
+    if (err.code === "EADDRINUSE") {
+      error(`Port ${port} is already in use! \n${err.message}`);
+      process.exit(1);
+    } else {
+      error(`Server error: \n${err.message}`);
+    }
+  });
+
+  // Graceful shutdown support for node --watch, nodemon, and cluster mode
+  const shutdown = () => {
+    // vibe_server.close stops accepting new connections
+    // Existing keep-alive connections will still prevent instant exit,
+    // so we force an exit if it takes longer than 3 seconds.
+    vibe_server.close(() => {
+      process.exit(0);
+    });
+    setTimeout(() => process.exit(0), 3000).unref();
+  };
+
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  process.on("message", (msg) => {
+    if (msg === "shutdown") shutdown();
   });
 }
 

package/utils/scaling/cache.js

@@ -145,7 +145,17 @@ export class LRUCache {
  */
 export function cacheMiddleware(cache) {
   return (req, res) => {
-    const key = LRUCache.key(req.method, req.url);
+    // Use the full original URL (includes query string) for the cache key.
+    // req.url is overwritten with just the pathname by the server internals,
+    // so we fall back to req._rawUrl which preserves the full URL.
+    // We also append serialized route params so that parameterised routes
+    // (e.g. /users/:id) with different param values get distinct cache entries.
+    const rawUrl = req._rawUrl || req.url;
+    const paramsStr =
+      req.params && Object.keys(req.params).length > 0
+        ? JSON.stringify(req.params)
+        : "";
+    const key = LRUCache.key(req.method, rawUrl + paramsStr);
     const entry = cache.get(key);
 
     if (entry) {
@@ -164,16 +174,45 @@ export function cacheMiddleware(cache) {
       return false; // Stop execution
     }
 
-    // Store original json method to intercept response
+    // Store original json and end methods to intercept response
     const originalJson = res.json.bind(res);
+    const originalEnd = res.end.bind(res);
+
+    // Intercept res.json (explicit json calls by handler)
     res.json = (data) => {
-      // Cache the response
       const newEntry = cache.set(key, data);
       res.setHeader("ETag", newEntry.etag);
       res.setHeader("X-Cache", "MISS");
       originalJson(data);
     };
 
+    // Intercept res.end (implicit return-value path in server.js uses
+    // res.writeHead + res.end directly, bypassing res.json).
+    // Note: res.getHeader() does NOT see headers set via res.writeHead(),
+    // so we can't check Content-Type that way. Instead, try JSON.parse directly.
+    res.end = (body) => {
+      if (body && !res._vibeCached) {
+        try {
+          const parsed = JSON.parse(body);
+          // Only cache plain objects/arrays — not error objects, not primitives
+          if (
+            typeof parsed === "object" &&
+            parsed !== null &&
+            !parsed.error // skip error responses
+          ) {
+            res._vibeCached = true;
+            const newEntry = cache.set(key, parsed);
+            // setHeader is safe here — headers not yet flushed
+            res.setHeader("ETag", newEntry.etag);
+            res.setHeader("X-Cache", "MISS");
+          }
+        } catch {
+          // Not JSON — skip caching
+        }
+      }
+      originalEnd(body);
+    };
+
     return true; // Continue to handler
   };
 }

package/vibe.d.ts

@@ -172,6 +172,57 @@ export interface RegisterOptions {
   [key: string]: any;
 }
 
+// ==========================================
+// Logging System
+// ==========================================
+
+export interface LoggerConfig {
+  /** If true, automatically logs request lifecycle hooks (Incoming Request, Request Completed) */
+  lifecycle?: boolean;
+  /** If true, formats JSON output into human-readable Vibe-styled terminal lines (like pino-pretty) */
+  prettyPrint?: boolean;
+  /** If true, applies ANSI color formatting to terminal logs. Default: true (unless overridden) */
+  colors?: boolean;
+  /** Destination for the logs. Accepts "console", "file", or "both". Default: "console" */
+  dest?: "console" | "file" | "both";
+  /** Absolute or relative path to the target log file. Active when dest is "file" or "both" */
+  logFile?: string;
+  /** Custom writable stream to output logs to (defaults to process.stdout) */
+  stream?: NodeJS.WritableStream;
+}
+
+/**
+ * Fastify/Pino-compatible structured logger API.
+ *
+ * All methods accept a message string OR a structured object (Pino-style).
+ * An optional color string can be passed as the last argument — in prettyPrint
+ * mode it will colorize the terminal output, in production mode it writes as
+ * a plain JSON `{ color: "..." }` key for log pipelines.
+ *
+ * @example
+ * req.log.info("Processing payment");
+ * req.log.info({ userId: 42, amount: 100 }, "Payment initiated");
+ * req.log.error(new Error("DB timeout"));
+ * req.log.warn("Slow query detected", "yellow");  // color override
+ */
+export interface LoggerAPI {
+  trace(obj: object | string | Error, msg?: string, color?: ColorName): void;
+  debug(obj: object | string | Error, msg?: string, color?: ColorName): void;
+  info(obj: object | string | Error, msg?: string, color?: ColorName): void;
+  warn(obj: object | string | Error, msg?: string, color?: ColorName): void;
+  error(obj: object | string | Error, msg?: string, color?: ColorName): void;
+  fatal(obj: object | string | Error, msg?: string, color?: ColorName): void;
+  /** Returns a child logger with merged bindings (e.g., { reqId }) */
+  child(bindings: Record<string, any>): LoggerAPI;
+}
+
+export interface VibeConfig {
+  /** Configuration for the native Vibe terminal logger */
+  logger?: LoggerConfig | boolean;
+  /** Enable automatic process restarting on crash. Spawns an internal cluster manager. Default: false */
+  autoRestart?: boolean;
+}
+
 // ==========================================
 // Request & Response Extensions
 // ==========================================
@@ -192,6 +243,10 @@ export interface VibeRequest extends IncomingMessage {
   ip?: string;
   /** Detailed client IP info */
   fullIp?: string;
+  /** Automatically generated UUID for the request lifecycle */
+  id: string;
+  /** Context-bound logger automatically stamped with the req.id constraint */
+  log: LoggerAPI;
   /** Custom properties added via decorateRequest */
   [key: string]: any;
 }
@@ -338,11 +393,14 @@ export interface RouterAPI {
   head: RouteRegistrar;
 
   /**
-   * Log helper
-   * @param value The message to log
-   * @param color Optional color name (e.g. 'green', 'red')
+   * Log helper supporting native colors and Vibe-stylized log levels
+   * @param value The message or object to log
+   * @param typeOrColor Optional color name (e.g. 'green') or level ('info', 'warn', 'error', 'req')
    */
-  log: (value: any, color?: ColorName) => void;
+  log: (
+    value: any,
+    typeOrColor?: ColorName | "info" | "error" | "warn" | "req",
+  ) => void;
 
   /** Register a global interceptor */
   plugin: (interceptor: Interceptor) => void;
@@ -401,15 +459,44 @@ export interface VibeApp extends RouterAPI {
     maybeFunc?: (router: RouterAPI) => void,
   ) => void;
 
-  /** Access app decorators */
+  /**
+   * Access app decorators
+   * @type {Record<string, any>}
+   */
   readonly decorators: Record<string, any>;
+
+  /**
+   * Override the default error handler (Fastify-style).
+   * Called for any unhandled `throw`, `return new Error()`, or `res.send(error)`.
+   * @example
+   * app.setErrorHandler((error, req, res) => {
+   *   req.log.error(error);
+   *   res.status(503).json({ success: false, message: error.message });
+   * });
+   */
+  setErrorHandler(
+    fn: (error: Error, req: VibeRequest, res: VibeResponse) => void,
+  ): void;
+
+  /**
+   * Pino/Fastify-compatible structured logger instance.
+   * Use for application-level logging outside of routes.
+   * @example
+   * app.log.info({ db: "connected" }, "Server ready");
+   * app.log.info("Server ready", "green"); // with color in prettyPrint mode
+   */
+  log: LoggerAPI;
+
+  /** Alias for `app.log` */
+  logger: LoggerAPI;
 }
 
 /**
  * Initialize a new Vibe application.
+ * @param config Optional application configuration
  * @returns Vibe application instance
  */
-export default function vibe(): VibeApp;
+export default function vibe(config?: VibeConfig): VibeApp;
 
 // ==========================================
 // LRU Cache

package/vibe.js

@@ -4,6 +4,9 @@ import { color } from "./utils/helpers/colors.js";
 import { RouteTrie } from "./utils/core/trie.js";
 import { PathToRegex } from "./utils/core/handler.js";
 import { compileSerializer } from "./utils/core/compile-serializer.js";
+import { createLogger, Logger } from "./utils/core/logger.js";
+import { handleError } from "./utils/core/handler.js";
+import { clusterize } from "./utils/scaling/cluster.js";
 
 /**
  * Helper to generate regex for a path
@@ -129,9 +132,12 @@ function pathToRegex(path) {
 
 /**
  * Initializes a Vibe application instance.
+ * @param {Object} [config={}]
+ * @param {Object|boolean} [config.logger] - Logger configuration
+ * @param {boolean} [config.autoRestart] - Restart server automatically on crash
  * @returns {VibeApp}
  */
-const vibe = () => {
+const vibe = (config = {}) => {
   // Route trie for O(log n) matching (used when routes > threshold)
   const trie = new RouteTrie();
 
@@ -144,6 +150,14 @@ const vibe = () => {
   // Static routes Map for O(1) lookup (routes without params)
   const staticRoutes = new Map();
 
+  // Logger initialization
+  const loggerConfig =
+    config.logger !== false ? config.logger || {} : { level: "silent" };
+  const appLogger =
+    config.logger instanceof Logger
+      ? config.logger
+      : createLogger(loggerConfig);
+
   // Internal configuration
   const options = {
     trie,
@@ -156,8 +170,27 @@ const vibe = () => {
     decorators: {},
     requestDecorators: {},
     replyDecorators: {},
+    logger: appLogger,
+    loggerConfig,
+    errorHandler: handleError,
   };
 
+  // Add global uncaught exception handler to prevent silent deaths and log cleanly
+  process.on("uncaughtException", (err) => {
+    appLogger.fatal(err, "Uncaught Exception crashed the server");
+    // Only exit here if we're not exiting gracefully anyway,
+    // cluster manager will restart it.
+    setTimeout(() => process.exit(1), 100);
+  });
+
+  process.on("unhandledRejection", (reason, promise) => {
+    appLogger.fatal(
+      { err: reason },
+      "Unhandled Promise Rejection crashed the server",
+    );
+    setTimeout(() => process.exit(1), 100);
+  });
+
   // Register default landing route
   const defaultRoute = {
     method: "GET",
@@ -362,7 +395,13 @@ const vibe = () => {
       host = undefined;
     }
 
-    server(options, Number(port), host, callback);
+    const startServer = () => server(options, Number(port), host, callback);
+
+    if (config.autoRestart) {
+      clusterize(startServer, { workers: 1, restart: true });
+    } else {
+      startServer();
+    }
   }
 
   /**
@@ -460,6 +499,8 @@ const vibe = () => {
       throw new Error(`Decorator '${name}' already exists`);
     }
     options.decorators[name] = value;
+    // Also set directly on the app object for easy access (app.name)
+    if (app) app[name] = value;
   }
 
   /**
@@ -532,12 +573,13 @@ const vibe = () => {
   }
 
   /**
-   * Logs a message with optional color
-   * @param {string} message
-   * @param {string} [colorValue="reset"]
+   * Log messages out using the Vibe stylized legacy logger.
+   * Native string logging bypasses the Pino JSON interface.
    */
-  const log = (message, colorValue = "reset") =>
-    process.stdout.write(`${color[colorValue](message)}\n`);
+  const log = (message, typeOrColor = "reset") => {
+    const c = color[typeOrColor] || color.reset;
+    process.stdout.write(c(message) + "\n");
+  };
 
   // Build the app object with decorators
   const app = {
@@ -549,8 +591,13 @@ const vibe = () => {
     head,
     listen,
     logRoutes,
-    log,
+    log: appLogger, // Standard Fastify-like exposure (app.log.info())
+    logger: appLogger,
+    logLegacy: log,
     setPublicFolder,
+    setErrorHandler: (fn) => {
+      options.errorHandler = fn;
+    },
     include,
     plugin,
     register,