nuxt-server-log 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hamid Niakan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,248 @@
+<p align="center">
+  <img src="./assets/logo.png" alt="Nuxt Server Log" width="140" height="140">
+</p>
+
+<h1 align="center">Nuxt Server Log</h1>
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+Structured, per-request server-side logging for Nuxt (Nitro). For every incoming
+request it emits a single JSON log line that bundles together:
+
+- the **request** itself (method, path, status, duration, client IP, request id),
+- every **outgoing API call** made on the server while handling that request, and
+- every **error** thrown during that request.
+
+This works for both your API routes **and your server-rendered (SSR) pages**: when
+a page is rendered on the server, every data-fetching call your app makes during
+that render is captured under the page's request — so you can see exactly which
+upstream calls contributed to a page, how long each took, and which one made the
+page slow.
+
+This gives you one correlated, machine-readable record per request — ready to ship
+to Elasticsearch, Loki, Datadog, or any log pipeline that ingests JSON.
+
+- [✨ &nbsp;Release Notes](/CHANGELOG.md)
+
+## Features
+
+- 📦 &nbsp;**One JSON log per request** — request, API calls, and errors correlated by a shared `requestId`.
+- 🖥️ &nbsp;**SSR page insight** — see every upstream call a server-rendered page made during its render, and exactly how long each took.
+- 🌐 &nbsp;**Automatic outbound API tracking** — server-side `fetch` calls are captured with URL, status, method, and duration.
+- 🧨 &nbsp;**Automatic error capture** — unhandled Nitro errors are recorded against the request that caused them.
+- 🐢 &nbsp;**Slow-call warnings** — configurable thresholds warn on slow responses and slow API calls.
+- 🔐 &nbsp;**Query redaction** — sensitive query params (tokens, passwords, …) are redacted by default.
+- 🎚️ &nbsp;**Sampling & filtering** — log a fraction of traffic and exclude noisy paths.
+- 🪪 &nbsp;**`X-Request-ID` header** — added to every response for end-to-end tracing.
+- 🧷 &nbsp;**Crash-safe** — circular references and BigInt never break logging.
+
+## Quick Setup
+
+Install the module:
+
+```bash
+npx nuxt module add nuxt-server-log
+```
+
+Or manually:
+
+```bash
+npm install nuxt-server-log
+```
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ["nuxt-server-log"],
+});
+```
+
+That's it. Requests are now logged to the server console as JSON. ✨
+
+## Configuration
+
+Configure the module under the `serverLog` key in `nuxt.config.ts`:
+
+```ts
+export default defineNuxtConfig({
+  modules: ["nuxt-server-log"],
+  serverLog: {
+    logLevel: "info",
+    sampleRate: 1,
+    excludePaths: ["/__nuxt_error", "/_nuxt"],
+    apiDurationWarning: 1500,
+    responseDurationWarning: 3000,
+    remoteAddressHeader: "x-real-ip",
+    redactQueryKeys: ["token", "password", "secret"],
+    traceDepth: 10,
+  },
+});
+```
+
+| Option                    | Type                                     | Default                                                                                                          | Description                                                                                                            |
+| ------------------------- | ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `enabled`                 | `boolean`                                | `true`                                                                                                           | Master switch. When `false`, the module registers nothing.                                                             |
+| `logLevel`                | `"debug" \| "info" \| "warn" \| "error"` | `"info"`                                                                                                         | Minimum level for the module's own log messages (e.g. slow-call warnings). The per-request log line is always emitted. |
+| `sampleRate`              | `number`                                 | `1`                                                                                                              | Fraction of requests to log, from `0` (none) to `1` (all). E.g. `0.1` logs ~10% of requests.                           |
+| `excludePaths`            | `string[]`                               | `["/__nuxt_error"]`                                                                                              | Requests whose path **starts with** any of these are not logged.                                                       |
+| `apiDurationWarning`      | `number`                                 | `1500`                                                                                                           | Emit a `warn` when a captured API call exceeds this many milliseconds.                                                 |
+| `responseDurationWarning` | `number`                                 | `3000`                                                                                                           | Emit a `warn` when total request duration exceeds this many milliseconds.                                              |
+| `remoteAddressHeader`     | `string`                                 | `undefined`                                                                                                      | Header to read the client IP from (e.g. behind a proxy). Falls back to `X-Forwarded-For` / socket address.             |
+| `redactQueryKeys`         | `string[]`                               | `["token", "password", "secret", "apiKey", "api_key", "auth", "authorization", "access_token", "refresh_token"]` | Query-string keys whose values are replaced with `[REDACTED]` in logs (case-insensitive).                              |
+| `traceDepth`              | `number`                                 | `10`                                                                                                             | Maximum number of stack-trace frames recorded per error.                                                               |
+
+> [!NOTE]
+> `remoteAddressHeader` and `X-Forwarded-For` are client-controllable and can be
+> spoofed unless your app sits behind a trusted proxy that overwrites them.
+
+## How it works
+
+The module registers three pieces of Nitro runtime:
+
+1. **A server middleware** that opens a per-request context (via `AsyncLocalStorage`),
+   assigns a `requestId`, sets the `X-Request-ID` response header, and writes the
+   final JSON log line once the response finishes (or the connection closes).
+2. **A `fetch` interceptor** that wraps `globalThis.fetch`, so any server-side
+   API call is recorded into the current request's context.
+3. **An error hook** that records unhandled Nitro errors against the active request.
+
+Because everything is tied together through the request context, a single log line
+tells the full story of what happened during that request.
+
+## Example output
+
+A **server-rendered page** (`GET /`) whose render fetched data from four upstream
+APIs. The whole page took ~2s, and you can immediately see that one categories
+call (1259ms) dominated the render time:
+
+```json
+{
+  "@timestamp": "2026-06-19T11:32:03.271Z",
+  "requestId": "2ce40ef3-a8d0-4642-82d7-e15bcbf418dc",
+  "userAgent": "unknown",
+  "statusCode": 200,
+  "method": "GET",
+  "path": "/",
+  "query": "",
+  "remoteAddress": "::ffff:127.0.0.1",
+  "duration": 2012,
+  "apiCalls": [
+    {
+      "@timestamp": "2026-06-19T11:32:01.482Z",
+      "statusCode": 200,
+      "url": "https://api.example.com/v1/categories/",
+      "method": "GET",
+      "duration": 1259
+    },
+    {
+      "@timestamp": "2026-06-19T11:32:02.801Z",
+      "statusCode": 200,
+      "url": "https://api.example.com/v1/sliders/",
+      "method": "GET",
+      "duration": 91
+    }
+  ],
+  "errors": []
+}
+```
+
+An API route that made one upstream API call:
+
+```json
+{
+  "@timestamp": "2026-06-19T11:34:41.959Z",
+  "requestId": "ffbc6274-a7f0-40d6-86fe-1e4154ab1f1b",
+  "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+  "statusCode": 200,
+  "method": "GET",
+  "path": "/api/products",
+  "query": "?token=%5BREDACTED%5D&page=2",
+  "remoteAddress": "203.0.113.7",
+  "duration": 142,
+  "apiCalls": [
+    {
+      "@timestamp": "2026-06-19T11:34:41.820Z",
+      "statusCode": 200,
+      "url": "https://api.example.com/products?page=2",
+      "method": "GET",
+      "duration": 98
+    }
+  ],
+  "errors": []
+}
+```
+
+A request where an upstream call failed and an error was thrown:
+
+```json
+{
+  "@timestamp": "2026-06-19T11:35:02.114Z",
+  "requestId": "a18d2f90-1c4e-4b2a-9a77-2f0b5c9d11aa",
+  "userAgent": "node",
+  "statusCode": 500,
+  "method": "POST",
+  "path": "/api/checkout",
+  "query": "",
+  "remoteAddress": "203.0.113.7",
+  "duration": 233,
+  "apiCalls": [
+    {
+      "@timestamp": "2026-06-19T11:35:02.020Z",
+      "statusCode": 503,
+      "url": "https://payments.example.com/charge",
+      "method": "POST",
+      "duration": 180,
+      "error": "HTTP Error 503: Service Unavailable"
+    }
+  ],
+  "errors": [
+    {
+      "@timestamp": "2026-06-19T11:35:02.110Z",
+      "error": "Payment provider unavailable",
+      "type": "Error",
+      "trace": [
+        "at chargeCard (server/api/checkout.post.ts:24:11)",
+        "at handler (server/api/checkout.post.ts:10:3)"
+      ],
+      "action": "unhandled"
+    }
+  ]
+}
+```
+
+In addition to the per-request line, slow requests/calls produce standalone `warn`
+entries, e.g.:
+
+```json
+{
+  "@timestamp": "…",
+  "level": "warn",
+  "message": "Slow API call detected",
+  "requestId": "…",
+  "url": "https://api.example.com/products",
+  "duration": 1820
+}
+```
+
+## Contribution
+
+Contributions are welcome! The flow is the standard GitHub one: fork the repo,
+create a branch, and open a pull request.
+
+## License
+
+[MIT](./LICENSE)
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/nuxt-server-log/latest.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-version-href]: https://npmjs.com/package/nuxt-server-log
+[npm-downloads-src]: https://img.shields.io/npm/dm/nuxt-server-log.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-downloads-href]: https://npm.chart.dev/nuxt-server-log
+[license-src]: https://img.shields.io/npm/l/nuxt-server-log.svg?style=flat&colorA=020420&colorB=00DC82
+[license-href]: https://npmjs.com/package/nuxt-server-log
+[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt
+[nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -0,0 +1,23 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { LoggerRuntimeConfig } from '../dist/runtime/types.js';
+
+interface ModuleOptions {
+    enabled?: boolean;
+    logLevel?: "debug" | "info" | "warn" | "error";
+    sampleRate?: number;
+    excludePaths?: string[];
+    apiDurationWarning?: number;
+    responseDurationWarning?: number;
+    remoteAddressHeader?: string;
+    redactQueryKeys?: string[];
+    traceDepth?: number;
+}
+declare module "@nuxt/schema" {
+    interface RuntimeConfig {
+        logger: LoggerRuntimeConfig;
+    }
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "nuxt-server-log",
+  "configKey": "serverLog",
+  "version": "0.1.1",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,43 @@
+import { defineNuxtModule, createResolver, addServerHandler, addServerPlugin } from 'nuxt/kit';
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "nuxt-server-log",
+    configKey: "serverLog"
+  },
+  defaults: {
+    enabled: true,
+    logLevel: "info",
+    sampleRate: 1,
+    excludePaths: ["/__nuxt_error"],
+    apiDurationWarning: 1500,
+    responseDurationWarning: 3e3,
+    redactQueryKeys: [
+      "token",
+      "password",
+      "secret",
+      "apiKey",
+      "api_key",
+      "auth",
+      "authorization",
+      "access_token",
+      "refresh_token"
+    ],
+    traceDepth: 10
+  },
+  setup(options, nuxt) {
+    if (!options.enabled) return;
+    const resolver = createResolver(import.meta.url);
+    nuxt.options.runtimeConfig.logger = { ...options };
+    addServerHandler({
+      middleware: true,
+      handler: resolver.resolve("./runtime/server/middleware/logger")
+    });
+    addServerPlugin(
+      resolver.resolve("./runtime/server/plugins/apiInterceptor")
+    );
+    addServerPlugin(resolver.resolve("./runtime/server/plugins/errorLogger"));
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/server/middleware/logger.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/runtime/server/middleware/logger.js

@@ -0,0 +1,71 @@
+import {
+  defineEventHandler,
+  getRequestURL,
+  getHeaders,
+  getRequestIP
+} from "h3";
+import { requestContext } from "../utils/context.js";
+import { logger } from "../utils/logger.js";
+import { redactQueryString } from "../utils/helpers.js";
+import { randomUUID } from "node:crypto";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig().logger;
+  const url = getRequestURL(event);
+  if (config.excludePaths?.some((path) => url.pathname.startsWith(path)))
+    return;
+  if (Math.random() > (config.sampleRate ?? 1)) return;
+  const requestId = getHeaders(event)["x-request-id"] || randomUUID();
+  const startTime = performance.now();
+  const ctx = {
+    requestId,
+    startTime,
+    event,
+    apiCalls: [],
+    errors: [],
+    metaData: {}
+  };
+  requestContext.enterWith(ctx);
+  event.node.res.setHeader("X-Request-ID", requestId);
+  let logged = false;
+  const writeRequestLog = () => {
+    if (logged) return;
+    logged = true;
+    const duration = performance.now() - startTime;
+    const headers = getHeaders(event);
+    const logEntry = {
+      "@timestamp": (/* @__PURE__ */ new Date()).toISOString(),
+      requestId,
+      userAgent: headers["user-agent"] || "unknown",
+      statusCode: event.node.res.statusCode,
+      method: event.method,
+      path: url.pathname,
+      query: redactQueryString(url.search, config.redactQueryKeys ?? []),
+      // `xForwardedFor` trusts the X-Forwarded-For header, which is spoofable
+      // unless requests pass through a trusted proxy. Set `remoteAddressHeader`
+      // to read the client IP from a header your proxy controls instead.
+      remoteAddress: (config.remoteAddressHeader ? headers[config.remoteAddressHeader] : void 0) || getRequestIP(event, { xForwardedFor: true }),
+      duration: Math.round(duration),
+      apiCalls: ctx.apiCalls,
+      errors: ctx.errors,
+      metadata: Object.keys(ctx.metaData).length > 0 ? ctx.metaData : void 0
+    };
+    if (duration > config.responseDurationWarning) {
+      logger.warn("Slow response detected", {
+        duration: Math.round(duration),
+        path: url.pathname
+      });
+    }
+    ctx.apiCalls.forEach((call) => {
+      if (call.duration > config.apiDurationWarning) {
+        logger.warn("Slow API call detected", {
+          url: call.url,
+          duration: Math.round(call.duration)
+        });
+      }
+    });
+    logger.logRequest(logEntry);
+  };
+  event.node.res.on("finish", writeRequestLog);
+  event.node.res.on("close", writeRequestLog);
+});

package/dist/runtime/server/plugins/apiInterceptor.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/apiInterceptor.js

@@ -0,0 +1,43 @@
+import { addApiCall } from "../utils/context.js";
+import { defineNitroPlugin } from "nitropack/runtime";
+const FETCH_PATCHED = Symbol.for("nuxt-server-log:fetch-patched");
+export default defineNitroPlugin(() => {
+  const globalScope = globalThis;
+  if (globalScope[FETCH_PATCHED]) return;
+  globalScope[FETCH_PATCHED] = true;
+  const originalNativeFetch = globalThis.fetch;
+  globalThis.fetch = new Proxy(originalNativeFetch, {
+    apply: async (target, thisArg, args) => {
+      const [input, init = {}] = args;
+      const startTime = performance.now();
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const method = init.method || (typeof input === "object" && "method" in input ? input.method : "GET");
+      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+      let status = null;
+      let error;
+      try {
+        const response = await Reflect.apply(target, thisArg, args);
+        status = response.status;
+        if (!response.ok)
+          error = `HTTP Error ${status}: ${response.statusText || "Unknown Error"}`;
+        return response;
+      } catch (err) {
+        if (err instanceof Error) error = err.message;
+        else error = String(err);
+        status = null;
+        throw err;
+      } finally {
+        const duration = performance.now() - startTime;
+        const apiCall = {
+          "@timestamp": timestamp,
+          statusCode: status,
+          url,
+          method: method.toUpperCase(),
+          duration: Math.round(duration),
+          error
+        };
+        addApiCall(apiCall);
+      }
+    }
+  });
+});

package/dist/runtime/server/plugins/errorLogger.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/errorLogger.js

@@ -0,0 +1,10 @@
+import { logger } from "../utils/logger.js";
+import { defineNitroPlugin } from "nitropack/runtime";
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook("error", (error, { event }) => {
+    logger.error("Nitro Error!", error, {
+      path: event?.path,
+      method: event?.method
+    });
+  });
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json"
+}

package/dist/runtime/server/utils/context.d.ts

@@ -0,0 +1,31 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { H3Event } from "h3";
+export interface ApiCall {
+    "@timestamp": string;
+    statusCode: number | null;
+    url: string;
+    method: string;
+    duration: number;
+    error?: string;
+}
+export interface ErrorLog {
+    "@timestamp": string;
+    error: string;
+    type: string;
+    trace: string[];
+    action: "unhandled" | "caught" | "fatal";
+    context?: Record<string, unknown>;
+}
+export interface RequestContext {
+    requestId: string;
+    startTime: number;
+    event: H3Event;
+    apiCalls: ApiCall[];
+    errors: ErrorLog[];
+    metaData: Record<string, unknown>;
+}
+export declare const requestContext: AsyncLocalStorage<RequestContext>;
+export declare function getRequestContext(): RequestContext | undefined;
+export declare function addApiCall(call: ApiCall): void;
+export declare function addError(error: ErrorLog): void;
+export declare function setMetaData(key: string, value: unknown): void;

package/dist/runtime/server/utils/context.js

@@ -0,0 +1,17 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export const requestContext = new AsyncLocalStorage();
+export function getRequestContext() {
+  return requestContext.getStore();
+}
+export function addApiCall(call) {
+  const ctx = getRequestContext();
+  ctx?.apiCalls.push(call);
+}
+export function addError(error) {
+  const ctx = getRequestContext();
+  ctx?.errors.push(error);
+}
+export function setMetaData(key, value) {
+  const ctx = getRequestContext();
+  if (ctx) ctx.metaData[key] = value;
+}

package/dist/runtime/server/utils/helpers.d.ts

@@ -0,0 +1,3 @@
+export declare function parseStackTrace(stack?: string, depth?: number): string[];
+export declare function safeStringify(value: unknown): string;
+export declare function redactQueryString(search: string, redactKeys: string[]): string;

package/dist/runtime/server/utils/helpers.js

@@ -0,0 +1,35 @@
+export function parseStackTrace(stack, depth = 10) {
+  if (!stack) return [];
+  return stack.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("at ")).slice(0, depth);
+}
+export function safeStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(value, (_key, val) => {
+      if (typeof val === "bigint") return val.toString();
+      if (typeof val === "object" && val !== null) {
+        if (seen.has(val)) return "[Circular]";
+        seen.add(val);
+      }
+      return val;
+    });
+  } catch (err) {
+    return JSON.stringify({
+      logError: "Failed to serialize log entry",
+      reason: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+export function redactQueryString(search, redactKeys) {
+  if (!search || redactKeys.length === 0) return search;
+  const params = new URLSearchParams(search);
+  const lowered = redactKeys.map((key) => key.toLowerCase());
+  let changed = false;
+  for (const key of [...params.keys()]) {
+    if (lowered.includes(key.toLowerCase())) {
+      params.set(key, "[REDACTED]");
+      changed = true;
+    }
+  }
+  return changed ? `?${params.toString()}` : search;
+}

package/dist/runtime/server/utils/logger.d.ts

@@ -0,0 +1,18 @@
+import type { ErrorLog } from "./context.js";
+declare class Logger {
+    private static instance;
+    private logLevel?;
+    private levels;
+    private constructor();
+    static getInstance(): Logger;
+    private resolveLogLevel;
+    private shouldLog;
+    private formatLog;
+    debug(message: string, data?: Record<string, unknown>): void;
+    info(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    error(message: string, error?: Error, data?: Record<string, unknown>, action?: ErrorLog["action"]): void;
+    logRequest(data: Record<string, unknown>): void;
+}
+export declare const logger: Logger;
+export {};

package/dist/runtime/server/utils/logger.js

@@ -0,0 +1,69 @@
+import { getRequestContext } from "./context.js";
+import { parseStackTrace, safeStringify } from "./helpers.js";
+import { useRuntimeConfig } from "#imports";
+class Logger {
+  static instance;
+  logLevel;
+  levels = { debug: 0, info: 1, warn: 2, error: 3 };
+  constructor() {
+  }
+  static getInstance() {
+    if (!Logger.instance) Logger.instance = new Logger();
+    return Logger.instance;
+  }
+  resolveLogLevel() {
+    if (this.logLevel === void 0) {
+      const level = useRuntimeConfig().logger?.logLevel;
+      this.logLevel = level !== void 0 ? this.levels[level] ?? 1 : 1;
+    }
+    return this.logLevel;
+  }
+  shouldLog(level) {
+    return this.levels[level] >= this.resolveLogLevel();
+  }
+  formatLog(level, message, data) {
+    const ctx = getRequestContext();
+    const baseLog = {
+      "@timestamp": (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      requestId: ctx?.requestId,
+      ...data
+    };
+    return safeStringify(baseLog);
+  }
+  debug(message, data) {
+    if (this.shouldLog("debug"))
+      console.log(this.formatLog("debug", message, data));
+  }
+  info(message, data) {
+    if (this.shouldLog("info"))
+      console.log(this.formatLog("info", message, data));
+  }
+  warn(message, data) {
+    if (this.shouldLog("warn"))
+      console.warn(this.formatLog("warn", message, data));
+  }
+  error(message, error, data, action = "unhandled") {
+    if (this.shouldLog("error")) {
+      const config = useRuntimeConfig().logger;
+      const errorLog = {
+        "@timestamp": (/* @__PURE__ */ new Date()).toISOString(),
+        error: error?.message || message,
+        type: error?.name || "Error",
+        trace: parseStackTrace(error?.stack, config?.traceDepth),
+        action,
+        context: error?.cause ? { cause: error.cause } : void 0
+      };
+      const ctx = getRequestContext();
+      if (ctx) ctx.errors.push(errorLog);
+      console.error(
+        this.formatLog("error", message, { error: errorLog, data })
+      );
+    }
+  }
+  logRequest(data) {
+    console.log(safeStringify(data));
+  }
+}
+export const logger = Logger.getInstance();

package/dist/runtime/types.d.ts

@@ -0,0 +1,11 @@
+export interface LoggerRuntimeConfig {
+    enabled: boolean;
+    logLevel: "debug" | "info" | "warn" | "error";
+    sampleRate: number;
+    excludePaths: string[];
+    apiDurationWarning: number;
+    responseDurationWarning: number;
+    remoteAddressHeader?: string;
+    redactQueryKeys: string[];
+    traceDepth: number;
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "nuxt-server-log",
+  "version": "0.1.1",
+  "description": "A Nuxt module for structured server-side logging",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Hamid-Niakan/nuxt-server-log.git"
+  },
+  "packageManager": "npm@10.9.2",
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "author": {
+    "email": "hniakan@gmail.com",
+    "name": "Hamid Niakan"
+  },
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "logging",
+    "logger",
+    "structured-logging",
+    "request-logging",
+    "observability",
+    "nitro",
+    "SSR",
+    "server"
+  ],
+  "homepage": "https://github.com/Hamid-Niakan/nuxt-server-log#readme",
+  "bugs": {
+    "url": "https://github.com/Hamid-Niakan/nuxt-server-log/issues"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "workspaces": [
+    "playground"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
+  "peerDependencies": {
+    "nuxt": "^4.0.0"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^4.4.5"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.2.4",
+    "@nuxt/eslint-config": "^1.15.2",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.4.5",
+    "@nuxt/test-utils": "^4.0.3",
+    "@types/node": "latest",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.3.0",
+    "nuxt": "^4.4.5",
+    "typescript": "~6.0.3",
+    "vitest": "^4.1.5",
+    "vue-tsc": "^3.2.8"
+  }
+}