@witchcraft/nuxt-logger 0.0.1 → 0.0.3

package/README.md

@@ -46,7 +46,7 @@ Also redacts the `redact` key, but only in production, so you can put anything s
 The electron logger requires a bit of setup since electron's main cannot be passed the runtime config normally.
 
 This assumes the usage of
-[@witchcraft/nuxt-electron](todo) since it can handle this among other issues. Note this plugin needs to be before it in the plugins list.
+[@witchcraft/nuxt-electron](https://github.com/witchcraftjs/nuxt-electron) since it can handle this among other issues.
 
 There is a full example in the [@witchcraft/nuxt-electron playground](TODO).
 

package/dist/module.d.mts

@@ -0,0 +1,75 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { TransportMultiOptions } from 'pino';
+
+declare module "@nuxt/schema" {
+    interface PublicRuntimeConfig {
+        logger: Pick<ModuleOptions, "redact" | "additionalServerTransportTargets" | "disabledServerTransportTargets"> & {
+            logPath: string;
+        };
+    }
+}
+interface ModuleOptions {
+    /**
+     * See {@link https://getpino.io/#/docs/redaction?id=redaction Pino redaction options}.
+     */
+    redact: string[];
+    /** This is "~~/logs/${appName}.log" by default. It's recommended you change it to something like "/var/log/${appName}.log" in production. */
+    serverLogPath?: string;
+    /** This is "~~/logs/server.log" by default. */
+    devServerLogPath?: string;
+    /** The module tries to get the app name from `runtimeConfig.appInfo.name`, otherwise it uses the name of the `~~` directory by default. */
+    appName?: string;
+    /** @default false */
+    enableServerRequestLogging?: boolean;
+    /**
+     * Additional transport targets to add to the server transport.
+     * File and console + pino-pretty are added by default. See disabledServerTransportTargets for disabling a transport.
+     *
+     * Since some transports will require options, but passing them via the nuxt config will hard code them, there is an additional `_loadFromEnv` property that can list a list of dot seperated properties to load from `process.env` and `_contexts` to set what context it will run in.
+     *
+     * For example, to add `pino-loki`:
+     * ```ts
+     * additionalServerTransportTargets: [
+     *		{
+     *			target: "pino-loki",
+     * 		_contexts: ["server"], // can be any of ["server", "client", "electron-client", "electron-main"] (all by default)
+     *			_loadFromEnv: ["options.host", "options.basicAuth.username", "options.basicAuth.password"],
+     *			options: {
+     *				//...
+     *				labels: {
+     * 				// set additional labels
+     *					application: "...",
+     * 			},
+     * 			propsToLabels: ["level", ...don't forget to set your labels ],
+     * 			replaceTimestamp: true, // loki requires timestamps in a specific format
+     *				host: "PINO_LOKI_HOST",
+     *				basicAuth: {
+     * 				// don't forget the quotes!
+     *					username: "PINO_LOKI_BASIC_AUTH_USERNAME",
+     *					password: "PINO_LOKI_BASIC_AUTH_PASSWORD",
+     *				},
+     *			},
+     *		},
+     * ]
+     * ```
+     * The location for the auth part on grafana cloud is confusing as fuck, leaving this here for posterity.
+     *
+     * Go to https://grafana.com/orgs/YOURORGHERE/stacks => Details => Loki => Send Logs
+     *
+     * There you can get the user and create a token with write access and it sets the right stuff. It will then appear in https://YOURORGHERE.grafana.net/a/grafana-auth-app
+     *
+     * If nothing is erroring, you should be able to see grafana receiving logs in Drilldown => Logs => Logs (https://YOURORGHERE.grafana.net/drilldown).
+     *
+     * You can then create a dashboard based on your labels.
+     */
+    additionalServerTransportTargets?: (TransportMultiOptions["targets"][number] & {
+        _contexts?: ("server" | "client" | "electron-client" | "electron-main")[];
+        _loadFromEnv: string[];
+    })[];
+    /** Disable a transport target by it's target name. */
+    disabledServerTransportTargets?: string[];
+}
+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": "logger",
+  "configKey": "logger",
+  "version": "0.0.2",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,88 @@
+import { defineNuxtModule, createResolver, resolveAlias, resolvePath, addImportsDir, addServerImportsDir, addServerHandler, addPlugin } from '@nuxt/kit';
+import { defu } from 'defu';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const module = defineNuxtModule({
+  meta: {
+    name: "logger",
+    configKey: "logger"
+  },
+  defaults: {
+    redact: [
+      ...process.env.NODE_ENV === "development" ? [] : ["redact"],
+      `req.headers["sec-ch-ua"]`,
+      `req.headers.cookie`,
+      `req.headers["user-agent"]`,
+      `req.headers.authorization`,
+      `req.headers.referer`,
+      `req.headers["x-forwarded-for"]`,
+      `req.headers["set-cookie"]`,
+      // i don't think this is actually sensitive, but just in case
+      `req["sec-websocket-key"]`
+    ],
+    enableServerRequestLogging: false,
+    additionalServerTransportTargets: [],
+    disabledServerTransportTargets: []
+  },
+  async setup(options, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    options.devServerLogPath ??= path.relative(nuxt.options.rootDir, resolveAlias("~~/logs/server.log", nuxt.options.alias));
+    const maybeAppName = nuxt.options.runtimeConfig.public?.appInfo?.name;
+    const appName = options.appName ?? maybeAppName ?? path.basename(await resolvePath("~~", { alias: nuxt.options.alias }));
+    options.serverLogPath ??= path.relative(nuxt.options.rootDir, resolveAlias(`~~/logs/${appName}.log`, nuxt.options.alias));
+    if (process.env.NODE_ENV === "development") {
+      if (!await fs.stat(options.devServerLogPath).then(() => true).catch(() => false)) {
+        await fs.mkdir(path.dirname(options.devServerLogPath), {
+          recursive: true
+        });
+        await fs.writeFile(options.devServerLogPath, "");
+      }
+    } else {
+      if (!await fs.stat(options.serverLogPath).then(() => true).catch(() => false)) {
+        await fs.mkdir(path.dirname(options.serverLogPath), { recursive: true });
+        await fs.writeFile(options.serverLogPath, "");
+      }
+    }
+    nuxt.options.runtimeConfig.public.logger = defu(
+      nuxt.options.runtimeConfig.public.logger,
+      {
+        redact: options.redact,
+        logPath: nuxt.options.dev ? options.devServerLogPath : options.serverLogPath,
+        additionalServerTransportTargets: options.additionalServerTransportTargets,
+        disabledServerTransportTargets: options.disabledServerTransportTargets
+      }
+    );
+    if (nuxt.options.modules.includes("@witchcraft/nuxt-electron")) {
+      const opts = nuxt.options;
+      opts.electron ??= {};
+      opts.electron.electronOnlyRuntimeConfig ??= {};
+      opts.electron.electronOnlyRuntimeConfig.logger ??= {};
+      opts.electron.electronOnlyRuntimeConfig.logger.logPath = void 0;
+    }
+    for (const file of [
+      "./runtime",
+      "./runtime/server/middleware/log",
+      "./runtime/server/utils/useServerLogger"
+    ]) {
+      nuxt.options.build.transpile.push(resolve(file));
+    }
+    addImportsDir(resolve("./runtime/composables"));
+    addServerImportsDir(resolve("./runtime/server/utils"));
+    if (options.enableServerRequestLogging) {
+      addServerHandler({
+        middleware: true,
+        handler: resolve("./runtime/server/middleware/log")
+      });
+    }
+    addPlugin(resolve("./runtime/plugins/init"));
+    nuxt.options.alias["#logger"] = resolve("./runtime");
+    nuxt.hook("vite:extendConfig", (config) => {
+      config.optimizeDeps ??= {};
+      config.optimizeDeps.include ??= [];
+      config.optimizeDeps.include.push("pino");
+    });
+  }
+});
+
+export { module as default };

package/dist/runtime/composables/setupElectronMainToRendererLogging.d.ts

@@ -0,0 +1 @@
+export declare function setupElectronMainToRendererLogging(): void;

package/dist/runtime/composables/setupElectronMainToRendererLogging.js

@@ -0,0 +1,9 @@
+import { useLogger } from "./useLogger.js";
+const isElectronClient = typeof window !== "undefined" && "electron" in window && window.electron;
+export function setupElectronMainToRendererLogging() {
+  if (!isElectronClient) return;
+  const logger = useLogger();
+  window.electron?.api._logs.on((level, data) => {
+    logger[level](data);
+  });
+}

package/dist/runtime/composables/useLogger.d.ts

@@ -0,0 +1,4 @@
+export declare const useLogger: ({ redirectTo, redirectAll }?: {
+    redirectTo?: "electron";
+    redirectAll?: boolean | ((level: keyof import("pino").Logger, data: any) => boolean);
+}) => import("../shared/createUseLogger.js.js").BaseLogger;

package/dist/runtime/composables/useLogger.js

@@ -0,0 +1,3 @@
+import { useRuntimeConfig } from "#app";
+import { createUseLogger } from "../shared/createUseLogger.js";
+export const useLogger = createUseLogger(useRuntimeConfig);

package/dist/runtime/electron/createElectronLoggerApi.d.ts

@@ -0,0 +1,9 @@
+import type { ipcRenderer as IpcRenderer } from "electron";
+import type { Levels } from "../types.js.js";
+export type ElectronLoggerApi = {
+    log: (level: Levels, data: any) => void;
+    _logs: {
+        on(cb: (level: Levels, data: any) => void): void;
+    };
+};
+export declare function createElectronLoggerApi(ipcRenderer: typeof IpcRenderer): ElectronLoggerApi;

package/dist/runtime/electron/createElectronLoggerApi.js

@@ -0,0 +1,13 @@
+import { ELECTRON_LOG_TYPE } from "./types.js";
+export function createElectronLoggerApi(ipcRenderer) {
+  return {
+    log: (level, data) => ipcRenderer.send(ELECTRON_LOG_TYPE.TO_MAIN, { level, data }),
+    _logs: {
+      on(cb) {
+        ipcRenderer.on(ELECTRON_LOG_TYPE.FROM_MAIN_ON_RENDERER, (_event, level, data) => {
+          cb(level, data);
+        });
+      }
+    }
+  };
+}

package/dist/runtime/electron/index.d.ts

@@ -0,0 +1,4 @@
+export { createElectronLoggerApi, type ElectronLoggerApi } from "./createElectronLoggerApi.js";
+export { useElectronLogger } from "./useElectronLogger.js";
+export { wrapLoggerForElectron } from "./wrapLoggerForElectron.js";
+export * from "./types.js";

package/dist/runtime/electron/index.js

@@ -0,0 +1,4 @@
+export { createElectronLoggerApi } from "./createElectronLoggerApi.js";
+export { useElectronLogger } from "./useElectronLogger.js";
+export { wrapLoggerForElectron } from "./wrapLoggerForElectron.js";
+export * from "./types.js";

package/dist/runtime/electron/receiveFromRendererOnMain.d.ts

@@ -0,0 +1,2 @@
+import type { useElectronLogger } from "./useElectronLogger.js.js";
+export declare function receiveFromRendererOnMain(logger: ReturnType<typeof useElectronLogger>): void;

package/dist/runtime/electron/receiveFromRendererOnMain.js

@@ -0,0 +1,9 @@
+import { ipcMain } from "electron";
+import { ELECTRON_LOG_TYPE } from "./types.js";
+export function receiveFromRendererOnMain(logger) {
+  ipcMain.on(ELECTRON_LOG_TYPE.TO_MAIN, (_event, message) => {
+    if (typeof message.data === "object" && typeof message.level === "string") {
+      logger[message.level](message.data);
+    }
+  });
+}

package/dist/runtime/electron/types.d.ts

@@ -0,0 +1,6 @@
+import type { EnumLike } from "@alanscodelog/utils";
+export declare const ELECTRON_LOG_TYPE: {
+    FROM_MAIN_ON_RENDERER: "ELECTRON_LOG_TYPE.FROM_MAIN_ON_RENDERER";
+    TO_MAIN: "ELECTRON_LOG_TYPE.TO_MAIN";
+};
+export type ElectronLogType = EnumLike<typeof ELECTRON_LOG_TYPE>;

package/dist/runtime/electron/types.js

@@ -0,0 +1,5 @@
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray";
+export const ELECTRON_LOG_TYPE = enumFromArray([
+  "FROM_MAIN_ON_RENDERER",
+  "TO_MAIN"
+], "ELECTRON_LOG_TYPE.");

package/dist/runtime/electron/useElectronLogger.d.ts

@@ -0,0 +1,18 @@
+import type { PublicRuntimeConfig } from "@nuxt/schema";
+import { type BrowserWindow } from "electron";
+/**
+ * A simplified wrapper around pino for use in electron main. Note that it does not support child logger and is actually a simple wrapper around just the basic levels.
+ *
+ * This is in part because pino might get swapped out (see @{link usePino}, but also to allow us to forward messages to the renderer easily because otherwise to do so we would have to use a custom pino transport that then communicates back again with the main process to send messages to the correct window which is a ridiculous round trip for no benefit.
+ *
+ * This is seperate since it requires special handling because of the following:
+ * - We can't use useRuntimeConfig so it's injected by using vite define instead ({@link STATIC}).
+ * - We need to pass the logPath which is defined at runtime.
+ * - We need to use some electron only imports which causes problems for the regular server.
+ * - Pino needs to be told were to find it's workers electron side in prod.
+ * {@link https://github.com/pinojs/pino/blob/master/docs/bundling.md}
+ * Using vite's ?worker&url imports almost works (the paths are correct) but something about the transpiling breaks things I think.
+ */
+export declare function useElectronLogger(pinoConfig?: PublicRuntimeConfig["logger"], windows?: () => BrowserWindow[], { receiveFromRenderer }?: {
+    receiveFromRenderer?: boolean;
+}): Record<keyof import("pino").BaseLogger | keyof import("pino").LoggerExtras<never, boolean> | "customLevels" | "useOnlyCustomLevels", (data: any) => void>;

package/dist/runtime/electron/useElectronLogger.js

@@ -0,0 +1,69 @@
+import { keys } from "@alanscodelog/utils/keys";
+import { app } from "electron";
+import path from "node:path";
+import { pino } from "pino";
+import { receiveFromRendererOnMain } from "./receiveFromRendererOnMain.js";
+import { ELECTRON_LOG_TYPE } from "./types.js";
+import { getBaseOptions } from "../helpers/getBaseOptions.js";
+globalThis.__bundlerPathsOverrides = {
+  "pino-worker": `./node_modules/pino/lib/worker.js`,
+  "pino-worker-pipeline": `./node_modules/pino/lib/worker-pipeline.js`,
+  "thread-stream-worker": `./node_modules/thread-stream/lib/worker.js`,
+  "pino/file": `./node_modules/pino/file.js`,
+  "pino-pretty": `./node_modules/pino-pretty/index.js`
+};
+const bundlerOverrides = globalThis.__bundlerPathsOverrides;
+const appPath = app.getAppPath();
+for (const key of keys(bundlerOverrides)) {
+  bundlerOverrides[key] = path.resolve(appPath, bundlerOverrides[key]);
+}
+let initiated = false;
+const levels = ["error", "warn", "debug", "trace", "info", "fatal"];
+const logger = {};
+export function useElectronLogger(pinoConfig, windows, {
+  receiveFromRenderer = true
+} = {}) {
+  if (initiated && pinoConfig) {
+    throw new Error("Config can only be passed the first time when initiating.");
+  }
+  if (!initiated) {
+    if (!pinoConfig) {
+      throw new Error("Config must be passed the first time using useElectronLogger.");
+    }
+    if (!windows) {
+      throw new Error("windows getter must be passed the first time using useElectronLogger.");
+    }
+    initiated = true;
+    const { opts, transports, debug } = getBaseOptions(pinoConfig);
+    const pinoLogger = pino(
+      opts,
+      pino.transport(transports)
+    );
+    for (const level of levels) {
+      logger[level] = (data) => {
+        if (typeof data === "object") {
+          if (data.ns.startsWith("renderer:")) {
+            pinoLogger[level](data);
+            return;
+          } else if (!data.ns.startsWith("main:")) {
+            throw new Error(`Namespace on electron's main side must start with "main:", got ${data.ns} instead in log: ${JSON.stringify(data)}.`);
+          }
+        }
+        pinoLogger[level](data);
+        const wins = windows();
+        for (const win of wins) {
+          win.webContents.send(
+            ELECTRON_LOG_TYPE.FROM_MAIN_ON_RENDERER,
+            level,
+            data
+          );
+        }
+      };
+    }
+    if (receiveFromRenderer) {
+      receiveFromRendererOnMain(logger);
+    }
+    logger.debug({ ns: "main:log", ...debug });
+  }
+  return logger;
+}

package/dist/runtime/electron/wrapLoggerForElectron.d.ts

@@ -0,0 +1,5 @@
+import type { useElectronLogger } from "./useElectronLogger.js.js";
+/**
+ * Wraps a logger (prefixed the first argument's namespace key with "main:") for use in electron.
+ */
+export declare function wrapLoggerForElectron<T extends ReturnType<typeof useElectronLogger>>(logger: T, prefix?: string): T;

package/dist/runtime/electron/wrapLoggerForElectron.js

@@ -0,0 +1,9 @@
+export function wrapLoggerForElectron(logger, prefix = "main:") {
+  const res = {};
+  for (const key of Object.keys(logger)) {
+    res[key] = (...args) => {
+      logger[key]({ ...args[0], ns: prefix + args[0].ns }, ...args.slice(1));
+    };
+  }
+  return res;
+}

package/dist/runtime/helpers/getBaseOptions.d.ts

@@ -0,0 +1,13 @@
+import type { PublicRuntimeConfig } from "@nuxt/schema";
+import type { LoggerOptions, TransportMultiOptions } from "pino";
+export declare function getBaseOptions(config: PublicRuntimeConfig["logger"]): {
+    opts: LoggerOptions;
+    browserOpts: LoggerOptions;
+    transports: TransportMultiOptions;
+    debug: {
+        logPath: string;
+        resolvedLogPath: string;
+        writeLevel: string;
+        logLevel: string;
+    };
+};

package/dist/runtime/helpers/getBaseOptions.js

@@ -0,0 +1,121 @@
+import { get } from "@alanscodelog/utils/get";
+import { keys } from "@alanscodelog/utils/keys";
+import { readable } from "@alanscodelog/utils/readable";
+import { set } from "@alanscodelog/utils/set";
+import { walk } from "@alanscodelog/utils/walk";
+import path from "node:path";
+import { pino } from "pino";
+const levels = {
+  values: {
+    fatal: 60,
+    error: 50,
+    warn: 40,
+    info: 30,
+    debug: 20,
+    trace: 10
+  },
+  labels: {
+    10: "trace",
+    20: "debug",
+    30: "info",
+    40: "warn",
+    50: "error",
+    60: "fatal"
+  }
+};
+const isElectronClient = typeof window !== "undefined" && "electron" in window && window.electron;
+export function getBaseOptions(config) {
+  if (isElectronClient) {
+    delete config.logPath;
+  }
+  const {
+    redact,
+    logPath,
+    additionalServerTransportTargets,
+    disabledServerTransportTargets
+  } = config;
+  const validLevels = keys(levels.values);
+  if (process.env.LOG_LEVEL && !validLevels.includes(process.env.LOG_LEVEL)) {
+    throw new Error(`logLevel is not a valid level: ${readable(validLevels)}`);
+  }
+  const maybeElectronLogLevel = import.meta.client ? window.electron?.meta?.env?.LOG_LEVEL : void 0;
+  const maybeElectronLogWriteLevel = import.meta.client ? window.electron?.meta?.env?.LOG_WRITE_LEVEL : void 0;
+  const writeLevel = maybeElectronLogWriteLevel ?? maybeElectronLogLevel ?? process.env.LOG_WRITE_LEVEL ?? process.env.LOG_LEVEL ?? (import.meta.dev ? "debug" : void 0) ?? "warn";
+  const logLevel = maybeElectronLogWriteLevel ?? process.env.LOG_LEVEL ?? (import.meta.dev ? "debug" : void 0) ?? "debug";
+  const processedAdditionalServerTransportTargets = [];
+  const thisContexts = [
+    ...isElectronClient ? ["electron-client"] : [],
+    // might not be available, careful
+    ...import.meta?.electron ? ["electron-main"] : [],
+    ...import.meta.client ? ["client"] : [],
+    ...import.meta.server ? ["server"] : []
+  ];
+  for (const target of additionalServerTransportTargets ?? []) {
+    const contexts = target._contexts;
+    const contextMatches = contexts === void 0 || contexts.find((c) => thisContexts.includes(c));
+    if (!contextMatches) continue;
+    const propPaths = target._loadFromEnv;
+    const clone = walk(target, void 0, { save: true });
+    processedAdditionalServerTransportTargets.push(clone);
+    for (const propPath of propPaths) {
+      const splitPath = propPath.split(".");
+      if (propPath) {
+        set(clone, splitPath, process.env[get(clone, splitPath)]);
+      }
+    }
+    delete clone._loadFromEnv;
+  }
+  return {
+    debug: {
+      logPath,
+      resolvedLogPath: path.resolve(logPath),
+      writeLevel,
+      logLevel
+    },
+    opts: {
+      redact,
+      // do not under any circumstances change how level looks, it breaks the logging ??? :/
+      level: logLevel,
+      formatters: {
+        bindings: () => ({})
+      },
+      // @ts-expect-error https://github.com/pinojs/pino/issues/2260
+      timestamp: pino.stdTimeFunctions.isoTime
+    },
+    browserOpts: {
+      browser: {
+        asObject: false,
+        transmit: isElectronClient ? {
+          level: logLevel,
+          send: (level, logEvent) => {
+            if (!logEvent.messages[0]?.ns?.startsWith("main") && levels.values[level] < levels.values[writeLevel]) {
+              logEvent.messages[0].ns &&= `renderer:${logEvent.messages[0].ns}`;
+              window.electron.api.log(logEvent);
+            }
+          }
+        } : void 0
+      }
+    },
+    transports: {
+      targets: [
+        {
+          level: writeLevel,
+          target: "pino/file",
+          options: {
+            destination: path.resolve(logPath),
+            mkdir: true
+          }
+        },
+        {
+          level: logLevel,
+          target: "pino-pretty",
+          options: {
+            colorize: true
+          }
+        },
+        ...processedAdditionalServerTransportTargets ?? []
+        // not sure when target doesn't exist, #future investigate
+      ].filter((t) => !disabledServerTransportTargets?.includes(t.target))
+    }
+  };
+}

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

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/init.js

@@ -0,0 +1,23 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#imports";
+import { useLogger } from "../composables/useLogger.js";
+export default defineNuxtPlugin({
+  name: "client-init-log",
+  setup(nuxtApp) {
+    if (import.meta.client) {
+      nuxtApp.hook("app:created", () => {
+        const config = useRuntimeConfig().public;
+        const initialLog = { appInfo: config.appInfo };
+        if (window.navigator !== void 0) {
+          initialLog.environmentInfo = {
+            userAgent: navigator.userAgent
+          };
+        }
+        useLogger().info({ ns: "client:init", ...initialLog });
+      });
+    }
+  },
+  env: {
+    // don't run when rendering server-only or island components.
+    islands: false
+  }
+});

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,12 @@
+import { defineEventHandler, useServerLogger } from "#imports";
+export default defineEventHandler((event) => {
+  const logger = useServerLogger();
+  logger.trace({
+    ns: "server:req:all",
+    req: {
+      headers: event.node.req.headers,
+      method: event.node.req.method,
+      url: event.node.req.url
+    }
+  });
+});

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,21 @@
+import os from "node:os";
+import { defineNitroPlugin, useRuntimeConfig, useServerLogger } from "#imports";
+export default defineNitroPlugin((_nitroApp) => {
+  const cpus = os.cpus();
+  const environmentInfo = {
+    os: os.platform(),
+    osType: os.type(),
+    osVersion: os.release(),
+    arch: os.arch(),
+    nodeVersion: process.version,
+    cpu: cpus?.[0]?.model,
+    cpus: cpus.length,
+    totalMem: os.totalmem()
+  };
+  useServerLogger().info({
+    ns: "server:init",
+    appInfo: useRuntimeConfig().public,
+    environmentInfo,
+    isUsingTestingDb: process.env.LOCALSERVERDB
+  });
+});

package/dist/runtime/server/tsconfig.json

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

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

@@ -0,0 +1,4 @@
+export declare const useServerLogger: ({ redirectTo, redirectAll }?: {
+    redirectTo?: "electron";
+    redirectAll?: boolean | ((level: keyof import("pino").Logger, data: any) => boolean);
+}) => import("../../shared/createUseLogger.js.js").BaseLogger;

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

@@ -0,0 +1,3 @@
+import { useRuntimeConfig } from "#imports";
+import { createUseLogger } from "../../shared/createUseLogger.js";
+export const useServerLogger = createUseLogger(useRuntimeConfig);

package/dist/runtime/shared/createUseLogger.d.ts

@@ -0,0 +1,20 @@
+import type { RuntimeConfig } from "nuxt/schema";
+import { type Logger } from "pino";
+import type { Levels } from "../types.js.js";
+export type BaseLogger = Record<Levels, ((data: any) => void)> & {
+    flush: Logger["flush"];
+};
+/**
+    * This exists to allow creating useLogger both on the client and the server since for the module to work on the server we must import from `#imports` and have the module transpile the files, but this is not neccesary from the composable.
+    *
+    * So they both create useLogger by passing in useRuntimeConfig how they can.
+    */
+export declare function createUseLogger(rc: () => RuntimeConfig): ({ redirectTo, redirectAll }?: {
+    redirectTo?: "electron";
+    /**
+     * Prefixes all messages not coming from main with `renderer:` so that they will be forwarded.
+     *
+     * Can also be a function to filter what gets forwarded.
+     */
+    redirectAll?: boolean | ((level: keyof Logger, data: any) => boolean);
+}) => BaseLogger;

package/dist/runtime/shared/createUseLogger.js

@@ -0,0 +1,46 @@
+import { pino } from "pino";
+import { getBaseOptions } from "../helpers/getBaseOptions.js";
+const logger = {};
+export function createUseLogger(rc) {
+  let initiated = false;
+  return function useLogger({
+    redirectTo,
+    redirectAll = true
+  } = {}) {
+    const levels = ["error", "warn", "debug", "trace", "info", "fatal"];
+    if (!initiated) {
+      initiated = true;
+      const config = rc().public;
+      const { opts, transports, browserOpts, debug } = getBaseOptions(config.logger);
+      let transport;
+      if (import.meta.server) {
+        transport = pino.transport(transports);
+      }
+      const pinoLogger = pino(
+        {
+          ...opts,
+          ...import.meta.client ? browserOpts : {}
+        },
+        transport
+      );
+      for (const level of levels) {
+        logger[level] = (data) => {
+          if (redirectTo === "electron") {
+            if (typeof data === "object" && typeof data.ns === "string" && !data.ns.startsWith("main:")) {
+              if (data.ns.startsWith("renderer:")) {
+                window.electron?.api.log(level, data);
+              } else if (typeof redirectAll === "function" ? redirectAll(level, data) : redirectAll) {
+                data.ns = `renderer:${data.ns}`;
+                window.electron?.api.log(level, data);
+              }
+            }
+          }
+          pinoLogger[level](data);
+        };
+      }
+      logger.debug({ ns: "log", ...debug, enabledTransportTargets: transports.targets.map((t) => t?.target) });
+      return logger;
+    }
+    return logger;
+  };
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1 @@
+export type Levels = "error" | "warn" | "debug" | "trace" | "info" | "fatal";

package/dist/types.d.mts

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@witchcraft/nuxt-logger",
-	"version": "0.0.1",
+	"version": "0.0.3",
 	"description": "Nuxt module for logging.",
 	"repository": "witchcraftjs/nuxt-logger",
 	"license": "MIT",
@@ -41,7 +41,7 @@
 		"pino-pretty": "^11.2.2"
 	},
 	"dependencies": {
-		"@alanscodelog/tsconfigs": "^6.1.0",
+		"@alanscodelog/tsconfigs": "^6.2.0",
 		"@alanscodelog/utils": "^6.0.1",
 		"@nuxt/kit": "^4.0.3",
 		"defu": "latest",

package/src/module.ts

@@ -5,6 +5,7 @@ import {
 	addServerImportsDir,
 	createResolver,
 	defineNuxtModule,
+	resolveAlias,
 	resolvePath
 } from "@nuxt/kit"
 import { defu } from "defu"
@@ -25,7 +26,7 @@ export interface ModuleOptions {
 	 * See {@link https://getpino.io/#/docs/redaction?id=redaction Pino redaction options}.
 	 */
 	redact: string[]
-	/** This is "/var/log/testing/${appName}.log". */
+	/** This is "~~/logs/${appName}.log" by default. It's recommended you change it to something like "/var/log/${appName}.log" in production. */
 	serverLogPath?: string
 	/** This is "~~/logs/server.log" by default. */
 	devServerLogPath?: string
@@ -106,10 +107,10 @@ export default defineNuxtModule<ModuleOptions>({
 	},
 	async setup(options, nuxt) {
 		const { resolve } = createResolver(import.meta.url)
-		options.devServerLogPath ??= await resolvePath("~~/logs/server.log", { alias: nuxt.options.alias })
+		options.devServerLogPath ??= path.relative(nuxt.options.rootDir, resolveAlias("~~/logs/server.log", nuxt.options.alias))
 		const maybeAppName = (nuxt.options.runtimeConfig.public as any)?.appInfo?.name
 		const appName = options.appName ?? maybeAppName ?? path.basename(await resolvePath("~~", { alias: nuxt.options.alias }))
-		options.serverLogPath ??= `/var/log/testing/${appName}.log`
+		options.serverLogPath ??= path.relative(nuxt.options.rootDir, resolveAlias(`~~/logs/${appName}.log`, nuxt.options.alias))
 		if (process.env.NODE_ENV === "development") {
 			if (!await fs.stat(options.devServerLogPath).then(() => true).catch(() => false)) {
 				await fs.mkdir(path.dirname(options.devServerLogPath), {

package/src/runtime/helpers/getBaseOptions.ts

@@ -4,6 +4,7 @@ import { readable } from "@alanscodelog/utils/readable"
 import { set } from "@alanscodelog/utils/set"
 import { walk } from "@alanscodelog/utils/walk"
 import type { PublicRuntimeConfig } from "@nuxt/schema"
+import path from "node:path"
 import type { LoggerOptions, TransportMultiOptions } from "pino"
 import { pino } from "pino"
 
@@ -38,6 +39,7 @@ export function getBaseOptions(
 	transports: TransportMultiOptions
 	debug: {
 		logPath: string
+		resolvedLogPath: string
 		writeLevel: string
 		logLevel: string
 	}
@@ -103,6 +105,7 @@ export function getBaseOptions(
 	return {
 		debug: {
 			logPath,
+			resolvedLogPath: path.resolve(logPath),
 			writeLevel,
 			logLevel
 		},
@@ -113,6 +116,7 @@ export function getBaseOptions(
 			formatters: {
 				bindings: () => ({})
 			},
+			// @ts-expect-error https://github.com/pinojs/pino/issues/2260
 			timestamp: pino.stdTimeFunctions.isoTime
 		},
 		browserOpts: {
@@ -137,7 +141,7 @@ export function getBaseOptions(
 					level: writeLevel,
 					target: "pino/file",
 					options: {
-						destination: logPath,
+						destination: path.resolve(logPath),
 						mkdir: true
 					}
 				},