hotelme-nuxt-logger 1.0.4 → 1.1.0

package/dist/module.cjs

@@ -14,12 +14,17 @@ const module$1 = kit.defineNuxtModule({
     }
   },
   defaults: {
-    enableRequestLogging: true
+    enableRequestLogging: true,
+    enableErrorLogging: true,
+    enableClientErrorLogging: true,
+    clientErrorEndpoint: "/_logger/client-error"
   },
   setup(options, nuxt) {
     const moduleDir = typeof __dirname !== "undefined" ? __dirname : path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('module.cjs', document.baseURI).href))));
     const resolver = kit.createResolver(moduleDir);
     nuxt.options.runtimeConfig.public.projectName = options.projectName || process.env.NUXT_PUBLIC_PROJECT_NAME || "hotelme";
+    const clientErrorEndpoint = options.clientErrorEndpoint || "/_logger/client-error";
+    nuxt.options.runtimeConfig.public.loggerClientErrorEndpoint = clientErrorEndpoint;
     kit.addImportsDir(resolver.resolve("./runtime"));
     if (options.enableRequestLogging) {
       kit.addServerHandler({
@@ -27,6 +32,20 @@ const module$1 = kit.defineNuxtModule({
         middleware: true
       });
     }
+    if (options.enableErrorLogging) {
+      kit.addServerPlugin(resolver.resolve("./runtime/server/plugin"));
+    }
+    if (options.enableClientErrorLogging) {
+      kit.addPlugin({
+        src: resolver.resolve("./runtime/plugins/error"),
+        mode: "all"
+      });
+      kit.addServerHandler({
+        route: clientErrorEndpoint,
+        method: "post",
+        handler: resolver.resolve("./runtime/server/routes/client-error.post")
+      });
+    }
   }
 });
 

package/dist/module.d.cts

@@ -9,6 +9,24 @@ interface ModuleOptions {
      * @default true
      */
     enableRequestLogging?: boolean;
+    /**
+     * Глобальний відлов помилок на сервері: Nitro `error` hook,
+     * `unhandledRejection` та `uncaughtException`.
+     * @default true
+     */
+    enableErrorLogging?: boolean;
+    /**
+     * Vue / Nuxt error hooks (SSR + браузер) та серверна ручка
+     * `/_logger/client-error`, через яку клієнтські помилки потрапляють
+     * у той самий stdout, що й серверні.
+     * @default true
+     */
+    enableClientErrorLogging?: boolean;
+    /**
+     * Шлях ручки, на яку браузерний плагін шле звіти про помилки.
+     * @default '/_logger/client-error'
+     */
+    clientErrorEndpoint?: string;
 }
 declare const _default: any;
 

package/dist/module.d.mts

@@ -9,6 +9,24 @@ interface ModuleOptions {
      * @default true
      */
     enableRequestLogging?: boolean;
+    /**
+     * Глобальний відлов помилок на сервері: Nitro `error` hook,
+     * `unhandledRejection` та `uncaughtException`.
+     * @default true
+     */
+    enableErrorLogging?: boolean;
+    /**
+     * Vue / Nuxt error hooks (SSR + браузер) та серверна ручка
+     * `/_logger/client-error`, через яку клієнтські помилки потрапляють
+     * у той самий stdout, що й серверні.
+     * @default true
+     */
+    enableClientErrorLogging?: boolean;
+    /**
+     * Шлях ручки, на яку браузерний плагін шле звіти про помилки.
+     * @default '/_logger/client-error'
+     */
+    clientErrorEndpoint?: string;
 }
 declare const _default: any;
 

package/dist/module.d.ts

@@ -9,6 +9,24 @@ interface ModuleOptions {
      * @default true
      */
     enableRequestLogging?: boolean;
+    /**
+     * Глобальний відлов помилок на сервері: Nitro `error` hook,
+     * `unhandledRejection` та `uncaughtException`.
+     * @default true
+     */
+    enableErrorLogging?: boolean;
+    /**
+     * Vue / Nuxt error hooks (SSR + браузер) та серверна ручка
+     * `/_logger/client-error`, через яку клієнтські помилки потрапляють
+     * у той самий stdout, що й серверні.
+     * @default true
+     */
+    enableClientErrorLogging?: boolean;
+    /**
+     * Шлях ручки, на яку браузерний плагін шле звіти про помилки.
+     * @default '/_logger/client-error'
+     */
+    clientErrorEndpoint?: string;
 }
 declare const _default: any;
 

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": "^3.0.0 || ^4.0.0"
   },
-  "version": "1.0.4",
+  "version": "1.1.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "2.0.0"

package/dist/module.mjs

@@ -1,4 +1,4 @@
-import { defineNuxtModule, createResolver, addImportsDir, addServerHandler } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addImportsDir, addServerHandler, addServerPlugin, addPlugin } from '@nuxt/kit';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 
@@ -20,12 +20,17 @@ const module = defineNuxtModule({
     }
   },
   defaults: {
-    enableRequestLogging: true
+    enableRequestLogging: true,
+    enableErrorLogging: true,
+    enableClientErrorLogging: true,
+    clientErrorEndpoint: "/_logger/client-error"
   },
   setup(options, nuxt) {
     const moduleDir = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
     const resolver = createResolver(moduleDir);
     nuxt.options.runtimeConfig.public.projectName = options.projectName || process.env.NUXT_PUBLIC_PROJECT_NAME || "hotelme";
+    const clientErrorEndpoint = options.clientErrorEndpoint || "/_logger/client-error";
+    nuxt.options.runtimeConfig.public.loggerClientErrorEndpoint = clientErrorEndpoint;
     addImportsDir(resolver.resolve("./runtime"));
     if (options.enableRequestLogging) {
       addServerHandler({
@@ -33,6 +38,20 @@ const module = defineNuxtModule({
         middleware: true
       });
     }
+    if (options.enableErrorLogging) {
+      addServerPlugin(resolver.resolve("./runtime/server/plugin"));
+    }
+    if (options.enableClientErrorLogging) {
+      addPlugin({
+        src: resolver.resolve("./runtime/plugins/error"),
+        mode: "all"
+      });
+      addServerHandler({
+        route: clientErrorEndpoint,
+        method: "post",
+        handler: resolver.resolve("./runtime/server/routes/client-error.post")
+      });
+    }
   }
 });
 

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

@@ -1,4 +1,5 @@
 import { defineEventHandler, getRequestURL } from "h3";
+import { useRuntimeConfig } from "#imports";
 import { logger } from "../logger.js";
 import { v4 as uuidv4 } from "uuid";
 export default defineEventHandler(async (event) => {
@@ -6,7 +7,8 @@ export default defineEventHandler(async (event) => {
     return;
   }
   try {
-    const projectName = event.context.$config?.public?.projectName || "hotelme";
+    const config = useRuntimeConfig();
+    const projectName = config.public.projectName || "hotelme";
     let reqid = event.node.req.headers["x-request-id"];
     if (!reqid) {
       reqid = uuidv4().replace(/-/g, "");
@@ -27,7 +29,8 @@ export default defineEventHandler(async (event) => {
           const statusCode = res.statusCode;
           const isApiRequest = fullUrl.startsWith("/api/");
           const msg = isApiRequest ? "api request" : "stats";
-          logger.info(msg, {
+          const level = statusCode >= 500 ? "error" : statusCode >= 400 ? "warn" : "info";
+          logger[level](msg, {
             reqid,
             project: projectName,
             stage: "after",

package/dist/runtime/plugins/error.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Captures errors that the Nitro `error` hook does not see:
+ * - SSR Vue render errors (`vue:error`, `app:error`) — logged directly through the JSON logger.
+ * - Browser Vue/JS errors and unhandled promise rejections — POSTed to `/_logger/client-error`,
+ *   which then re-emits them through the same logger on the server.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/plugins/error.js

@@ -0,0 +1,73 @@
+import { defineNuxtPlugin, useRequestEvent, useRuntimeConfig } from "#imports";
+import { logger } from "../logger.js";
+export default defineNuxtPlugin((nuxtApp) => {
+  if (import.meta.server) {
+    const event = useRequestEvent();
+    const reqid = event?.context?.reqid;
+    const request = event?.path;
+    nuxtApp.hook("vue:error", (err, _instance, info) => {
+      logger.error("vue_ssr_error", {
+        reqid,
+        request,
+        info,
+        error: err?.message ?? String(err),
+        error_name: err?.name,
+        stack: err?.stack
+      });
+    });
+    nuxtApp.hook("app:error", (err) => {
+      logger.error("app_ssr_error", {
+        reqid,
+        request,
+        error: err?.message ?? String(err),
+        error_name: err?.name,
+        stack: err?.stack
+      });
+    });
+    return;
+  }
+  const endpoint = useRuntimeConfig().public.loggerClientErrorEndpoint || "/_logger/client-error";
+  const post = (msg, payload) => {
+    try {
+      fetch(endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          msg,
+          page: typeof location !== "undefined" ? location.pathname + location.search : void 0,
+          ...payload
+        }),
+        keepalive: true
+      }).catch(() => {
+      });
+    } catch {
+    }
+  };
+  nuxtApp.hook("vue:error", (err, _i, info) => {
+    post("vue_client_error", {
+      info,
+      error: err?.message ?? String(err),
+      error_name: err?.name,
+      stack: err?.stack
+    });
+  });
+  window.addEventListener("error", (e) => {
+    const err = e.error;
+    post("window_error", {
+      error: err?.message ?? e.message,
+      error_name: err?.name,
+      stack: err?.stack,
+      file: e.filename,
+      line: e.lineno,
+      col: e.colno
+    });
+  });
+  window.addEventListener("unhandledrejection", (e) => {
+    const reason = e.reason;
+    post("window_unhandled_rejection", {
+      error: reason?.message ?? String(reason),
+      error_name: reason?.name,
+      stack: reason?.stack
+    });
+  });
+});

package/dist/runtime/server/plugin.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Nitro plugin that turns every unhandled error into a structured JSON log line.
+ *
+ * Sources covered:
+ * - All errors thrown from server middleware / event handlers (`nitroApp.hooks.hook('error')`).
+ * - `unhandledRejection` and `uncaughtException` at the Node process level.
+ *
+ * `reqid` is read from `event.context.reqid` set by `logger.server.ts` middleware,
+ * so SSR and backend logs stay correlated by the same id.
+ */
+declare const _default: import("nitropack").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugin.js

@@ -0,0 +1,36 @@
+import { defineNitroPlugin } from "nitropack/runtime";
+import { logger } from "../logger.js";
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook("error", (error, ctx) => {
+    const event = ctx?.event;
+    const req = event?.node?.req;
+    const res = event?.node?.res;
+    logger.error("unhandled_error", {
+      reqid: event?.context?.reqid,
+      domain: req?.headers?.host,
+      request: event?.path || req?.url,
+      method: req?.method,
+      response: res?.statusCode,
+      error: error instanceof Error ? error.message : String(error),
+      error_name: error instanceof Error ? error.name : void 0,
+      stack: error instanceof Error ? error.stack : void 0
+    });
+  });
+  const g = globalThis;
+  if (g.__hotelmeLoggerProcessHooks) return;
+  g.__hotelmeLoggerProcessHooks = true;
+  process.on("unhandledRejection", (reason) => {
+    logger.fatal("unhandled_rejection", {
+      error: reason instanceof Error ? reason.message : String(reason),
+      error_name: reason instanceof Error ? reason.name : void 0,
+      stack: reason instanceof Error ? reason.stack : void 0
+    });
+  });
+  process.on("uncaughtException", (err) => {
+    logger.fatal("uncaught_exception", {
+      error: err.message,
+      error_name: err.name,
+      stack: err.stack
+    });
+  });
+});

package/dist/runtime/server/routes/client-error.post.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Receives error reports from the browser plugin and emits them through the
+ * same JSON logger, so server stdout becomes the single sink for all errors.
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    ok: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/routes/client-error.post.js

@@ -0,0 +1,14 @@
+import { defineEventHandler, readBody } from "h3";
+import { logger } from "../../logger.js";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event).catch(() => ({}));
+  const { msg, ...rest } = body || {};
+  logger.error(typeof msg === "string" && msg ? msg : "client_error", {
+    reqid: event.context.reqid,
+    domain: event.node.req.headers.host,
+    referer: event.node.req.headers.referer,
+    user_agent: event.node.req.headers["user-agent"],
+    ...rest
+  });
+  return { ok: true };
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hotelme-nuxt-logger",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "Стандартний logger для Nuxt проектів з JSON виводом сумісним з бекенд-логами",
   "keywords": [
     "nuxt",