@witchcraft/nuxt-logger 0.0.1

package/README.md

@@ -0,0 +1,145 @@
+# @witchcraft/nuxt-logger
+
+[![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]
+
+
+Nuxt isomorphic-ish logging module (it can be used on the client/server/electron) and automatically adds a transport on the server and electron main to save logs to a file. 
+
+It's simplified wrapper around pino that exposes only the default logger methods.
+
+
+- [🏀 Online playground](https://stackblitz.com/github/witchcraftjs/nuxt-logger?file=playground%2Fapp.vue)
+
+## Features
+
+- Creates a nuxt plugin client side to log environment info (`info`).
+- Creates a server middleware for logging requests (`trace`) with customizable redaction.
+- `useLogger` composable for creating a client logger.
+- `useServerLogger` composable for creating a server logger.
+- `useElectronLogger` for electron + utilities for setting things up.
+
+## Install
+```bash
+pnpx nuxi module add @witchcraft/nuxt-logger
+```
+
+## Usage
+
+Just start using it with the `useLogger` or `useServerLogger` composable, they should be auto imported if you have auto imports on.
+
+```ts
+const logger = useLogger()
+logger.info({ns:"namespace", msg:"hello world"})
+```
+
+### Redaction
+
+By default redacts some known sensitive keys for the middleware logging requests.
+
+Also redacts the `redact` key, but only in production, so you can put anything semi-sensitive in there that you need to inspect in development.
+
+### Electron
+
+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.
+
+There is a full example in the [@witchcraft/nuxt-electron playground](TODO).
+
+```ts [main.ts]
+import { STATIC, useDevDataDir } from "@witchcraft/nuxt-electron/electron"
+import { ELECTRON } from "@witchcraft/nuxt-logger/electron"
+
+// assuming you stick your active window instances here
+const windows = []
+const userDataDir = useDevDataDir() ?? parsed(args).userDataDir ?? app.getPath("appData")
+
+// this only needs to be called like this the first time
+const logger = useElectronLogger(
+	{
+		...STATIC.ELECTRON_RUNTIME_CONFIG.logger,
+		// override the log path since with electron we only know it at runtime
+		// this module sets it to undefined for electron anyways
+		logPath: path.join(userDataDir, "log.txt"),
+	},
+	// give it a way to access windows to be able to communicate with them
+	() => windows,
+	{
+		// true by default, allows recieving logs from the renderer
+		recieveFromRenderer: true
+	}
+)
+// later/elsewhere
+// NOTE that the namespaces MUST begin with `main:`
+useElectronLogger().debug({ns:"main:hello"}) // will work
+
+```
+We can setup the apis for two way communication in the preload script.
+
+```ts
+// preload.ts
+import { contextBridge, ipcRenderer } from "electron"
+import { createElectronLoggerApi, type ElectronLoggerApi } from "@witchcraft/nuxt-logger/electron"
+
+declare global {
+	interface Window {
+		electron: {
+			api: ElectronLoggerApi {
+				//...
+			}
+		}
+	}
+}
+// creates window.electron.api.log/_logs
+// note the naming/structure must be like this, it's currently hardcoded
+contextBridge.exposeInMainWorld("electron", {
+	api: {
+		...createElectronLoggerApi(ipcRenderer) 
+	},
+	meta: {
+		env {
+			// the regular useLogger in the renderer will look for this variable automatically
+			LOG_LEVEL: process.env.LOG_LEVEL,
+			WRITE_LEVEL: process.env.LOG_WRITE_LEVEL,
+		}
+	}
+})
+```
+
+And receive `main`'s logs on the client. This must be called before other calls to `useLogger`.
+
+```vue
+// app.vue
+
+<script lang="ts" setup>
+// setup the regular client side logger
+useLogger({
+	// this is the default
+	redirectTo: "electron",
+	// prefixes all messages with `renderer:` so that they will be forwarded, can be a function
+	redirectAll: true, 
+})
+setupElectronMainToRendererLogging()
+
+useLogger().debug({ns: "renderer:hello"}) // will get forwarder
+useLogger().debug({ns: "hello"}) // will also get forwarded if redirectAll is true
+</script>
+```
+
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/@witchcraft/nuxt-logger/latest.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-version-href]: https://npmjs.com/package/@witchcraft/nuxt-logger
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/@witchcraft/nuxt-logger.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-downloads-href]: https://npmjs.com/package/@witchcraft/nuxt-logger
+
+[license-src]: https://img.shields.io/npm/l/@witchcraft/nuxt-logger.svg?style=flat&colorA=020420&colorB=00DC82
+[license-href]: https://npmjs.com/package/@witchcraft/nuxt-logger
+
+[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt.js
+[nuxt-href]: https://nuxt.com

package/package.json

@@ -0,0 +1,82 @@
+{
+	"name": "@witchcraft/nuxt-logger",
+	"version": "0.0.1",
+	"description": "Nuxt module for logging.",
+	"repository": "witchcraftjs/nuxt-logger",
+	"license": "MIT",
+	"type": "module",
+	"sideEffects": false,
+	"exports": {
+		".": {
+			"types": "./dist/types.d.mts",
+			"import": "./dist/module.mjs"
+		},
+		"./*": {
+			"types": "./dist/runtime/*.d.ts",
+			"import": "./dist/runtime/*.js"
+		},
+		"./electron": {
+			"types": "./dist/runtime/electron/index.d.ts",
+			"import": "./dist/runtime/electron/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"src"
+	],
+	"scripts": {
+		"prepare": "husky && cd playground && pnpm i",
+		"build": "nuxt-module-build prepare && nuxt-module-build build && nuxi build playground",
+		"build:only": "nuxt-module-build build",
+		"dev": "nuxi dev playground",
+		"dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+		"lint": "eslint \"{src,test,playground/app}/**/*.{ts,vue}\" \"*.{js,cjs,mjs,ts}\"",
+		"lint:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
+		"test": "vitest run",
+		"test:watch": "vitest watch"
+	},
+	"//peerDependencies": "Because we need the real paths to the workers, they must both be in the app's node_modules",
+	"peerDependencies": {
+		"pino": "^9.8.0",
+		"pino-pretty": "^11.2.2"
+	},
+	"dependencies": {
+		"@alanscodelog/tsconfigs": "^6.1.0",
+		"@alanscodelog/utils": "^6.0.1",
+		"@nuxt/kit": "^4.0.3",
+		"defu": "latest",
+		"pino": "^9.9.0",
+		"pino-pretty": "^11.3.0"
+	},
+	"devDependencies": {
+		"@alanscodelog/eslint-config": "^6.3.0",
+		"@alanscodelog/semantic-release-config": "^5.0.4",
+		"@nuxt/eslint-config": "^1.9.0",
+		"@nuxt/module-builder": "^1.0.2",
+		"@nuxt/schema": "^4.0.3",
+		"@nuxt/test-utils": "^3.19.2",
+		"@types/node": "latest",
+		"changelogen": "^0.6.2",
+		"electron": "^34.5.8",
+		"eslint": "^9.34.0",
+		"husky": "^9.1.7",
+		"nuxt": "^4.0.3",
+		"semantic-release": "^24.2.8",
+		"typescript": "^5.9.2",
+		"vitest": "^3.2.4",
+		"vue-tsc": "^2.2.12"
+	},
+	"release": {
+		"extends": [
+			"@alanscodelog/semantic-release-config"
+		]
+	},
+	"commitlint": {
+		"extends": [
+			"@alanscodelog"
+		]
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/src/module.ts

@@ -0,0 +1,173 @@
+import {
+	addImportsDir,
+	addPlugin,
+	addServerHandler,
+	addServerImportsDir,
+	createResolver,
+	defineNuxtModule,
+	resolvePath
+} from "@nuxt/kit"
+import { defu } from "defu"
+import fs from "node:fs/promises"
+import path from "node:path"
+import type { TransportMultiOptions } from "pino"
+
+declare module "@nuxt/schema" {
+	interface PublicRuntimeConfig {
+		logger: Pick<ModuleOptions, "redact" | "additionalServerTransportTargets" | "disabledServerTransportTargets"> & {
+			logPath: string
+		}
+	}
+}
+
+export interface ModuleOptions {
+	/**
+	 * See {@link https://getpino.io/#/docs/redaction?id=redaction Pino redaction options}.
+	 */
+	redact: string[]
+	/** This is "/var/log/testing/${appName}.log". */
+	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[]
+}
+
+export default defineNuxtModule<ModuleOptions>({
+	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"]`
+		] as string[],
+		enableServerRequestLogging: false,
+		additionalServerTransportTargets: [],
+		disabledServerTransportTargets: []
+	},
+	async setup(options, nuxt) {
+		const { resolve } = createResolver(import.meta.url)
+		options.devServerLogPath ??= await resolvePath("~~/logs/server.log", { alias: 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`
+		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 as any,
+			{
+				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 as any
+			opts.electron ??= {}
+			opts.electron.electronOnlyRuntimeConfig ??= {}
+			opts.electron.electronOnlyRuntimeConfig.logger ??= {}
+			opts.electron.electronOnlyRuntimeConfig.logger.logPath = undefined
+		}
+		// the server files require transpilation to use #imports and #logger
+		// they are needed, otherwise I can't seem to get the imports to resolve correctly
+		// see also runtime/shared/createUseLogger.ts
+		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 => {
+		// fixes https://github.com/nuxt/nuxt/issues/13247 partially (also transpiling it breaks it)
+			config.optimizeDeps ??= {}
+			config.optimizeDeps.include ??= []
+			config.optimizeDeps.include.push("pino")
+		})
+	}
+})

package/src/runtime/composables/setupElectronMainToRendererLogging.ts

@@ -0,0 +1,12 @@
+import { useLogger } from "./useLogger.js"
+
+// todo see about importing the composable from nuxt-electron
+const isElectronClient = (typeof window !== "undefined" && "electron" in window && window.electron)
+
+export function setupElectronMainToRendererLogging(): void {
+	if (!isElectronClient) return
+	const logger = useLogger()
+	;(window as any).electron?.api._logs.on((level: string, data: any) => {
+		(logger as any)[level](data)
+	})
+}

package/src/runtime/composables/useLogger.ts

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

package/src/runtime/electron/createElectronLoggerApi.ts

@@ -0,0 +1,23 @@
+import type {	ipcRenderer as IpcRenderer } from "electron"
+
+import { ELECTRON_LOG_TYPE } from "./types.js"
+
+import type { Levels } from "../types.js"
+
+export type ElectronLoggerApi = {
+	log: (level: Levels, data: any) => void
+	_logs: { on(cb: (level: Levels, data: any) => void): void }
+}
+
+export function createElectronLoggerApi(ipcRenderer: typeof IpcRenderer): ElectronLoggerApi {
+	return {
+		log: (level: Levels, data: any) => ipcRenderer.send(ELECTRON_LOG_TYPE.TO_MAIN, { level, data }),
+		_logs: {
+			on(cb: (level: Levels, data: any) => void) {
+				ipcRenderer.on(ELECTRON_LOG_TYPE.FROM_MAIN_ON_RENDERER, (_event, level, data) => {
+					cb(level, data)
+				})
+			}
+		}
+	}
+}

package/src/runtime/electron/index.ts

@@ -0,0 +1,6 @@
+// note adding file endings breaks build types
+export { createElectronLoggerApi, type ElectronLoggerApi } from "./createElectronLoggerApi"
+
+export { useElectronLogger } from "./useElectronLogger"
+export { wrapLoggerForElectron } from "./wrapLoggerForElectron"
+export * from "./types"

package/src/runtime/electron/receiveFromRendererOnMain.ts

@@ -0,0 +1,12 @@
+import { ipcMain } from "electron"
+
+import { ELECTRON_LOG_TYPE } from "./types.js"
+import type { useElectronLogger } from "./useElectronLogger.js"
+
+export function receiveFromRendererOnMain(logger: ReturnType<typeof useElectronLogger>): void {
+	ipcMain.on(ELECTRON_LOG_TYPE.TO_MAIN, (_event, message) => {
+		if (typeof message.data === "object" && typeof message.level === "string") {
+			logger[message.level as keyof typeof logger](message.data)
+		}
+	})
+}

package/src/runtime/electron/types.ts

@@ -0,0 +1,9 @@
+import type { EnumLike } from "@alanscodelog/utils"
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray"
+
+export const ELECTRON_LOG_TYPE = enumFromArray([
+	"FROM_MAIN_ON_RENDERER",
+	"TO_MAIN"
+], "ELECTRON_LOG_TYPE.")
+
+export type ElectronLogType = EnumLike<typeof ELECTRON_LOG_TYPE>

package/src/runtime/electron/useElectronLogger.ts

@@ -0,0 +1,98 @@
+import { keys } from "@alanscodelog/utils/keys"
+import type { PublicRuntimeConfig } from "@nuxt/schema"
+import { app, type BrowserWindow } from "electron"
+import path from "node:path"
+import { type Logger, pino } from "pino"
+
+import { receiveFromRendererOnMain } from "./receiveFromRendererOnMain.js"
+import { ELECTRON_LOG_TYPE } from "./types.js"
+
+import { getBaseOptions } from "../helpers/getBaseOptions.js"
+
+declare const globalThis: any
+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: (keyof Logger)[] = ["error", "warn", "debug", "trace", "info", "fatal"] as const
+const logger: Record<typeof levels[number], ((data: any) => void)> = {} as any
+
+/**
+ * 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 function useElectronLogger(
+	pinoConfig?: PublicRuntimeConfig["logger"],
+	windows?: () => BrowserWindow[], {
+		receiveFromRenderer = true
+	}: { receiveFromRenderer?: boolean } = {}
+) {
+	if (initiated && pinoConfig) {
+		throw new Error("Config can only be passed the first time when initiating.")
+	}
+	// doing initiated check because we need to be able to pass config from electron
+	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) {
+			// the references are safe
+
+			logger[level] = (data: any) => {
+				if (typeof data === "object") {
+					if (data.ns.startsWith("renderer:")) {
+						(pinoLogger as any)[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 as any)[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/src/runtime/electron/wrapLoggerForElectron.ts

@@ -0,0 +1,16 @@
+import type { useElectronLogger } from "./useElectronLogger.js"
+/**
+ * Wraps a logger (prefixed the first argument's namespace key with "main:") for use in electron.
+ */
+export function wrapLoggerForElectron<T extends ReturnType<typeof useElectronLogger>>(
+	logger: T,
+	prefix: string = "main:"
+): T {
+	const res = {}
+	for (const key of Object.keys(logger)) {
+		res[key] = (...args: any[]) => {
+			logger[key]({ ...args[0], ns: prefix + args[0].ns }, ...args.slice(1))
+		}
+	}
+	return res
+}

package/src/runtime/helpers/getBaseOptions.ts

@@ -0,0 +1,156 @@
+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 type { PublicRuntimeConfig } from "@nuxt/schema"
+import type { LoggerOptions, TransportMultiOptions } from "pino"
+import { pino } from "pino"
+
+// normally we would access logger.levels, but because we create
+// the shared config here we can't
+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: PublicRuntimeConfig["logger"]
+): {
+	opts: LoggerOptions
+	browserOpts: LoggerOptions
+	transports: TransportMultiOptions
+	debug: {
+		logPath: string
+		writeLevel: string
+		logLevel: string
+	}
+} {
+	// @ts-expect-error the path is wrong on electron's client side
+	// but it's not used anyways
+	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 as any)) {
+		throw new Error(`logLevel is not a valid level: ${readable(validLevels)}`)
+	}
+	const maybeElectronLogLevel = import.meta.client
+		? (window as any).electron?.meta?.env?.LOG_LEVEL
+		: undefined
+	const maybeElectronLogWriteLevel = import.meta.client
+		? (window as any).electron?.meta?.env?.LOG_WRITE_LEVEL
+		: undefined
+	const writeLevel: (typeof validLevels)[number]
+		= maybeElectronLogWriteLevel
+			?? maybeElectronLogLevel
+			?? process.env.LOG_WRITE_LEVEL as any
+			?? process.env.LOG_LEVEL as any
+			?? (import.meta.dev ? "debug" : undefined)
+			?? "warn"
+	const logLevel: (typeof validLevels)[number]
+		= maybeElectronLogWriteLevel
+			?? process.env.LOG_LEVEL as any
+			?? (import.meta.dev ? "debug" : undefined)
+			?? "debug"
+
+	const processedAdditionalServerTransportTargets = []
+	const thisContexts = [
+		...(isElectronClient ? ["electron-client"] : []),
+		// might not be available, careful
+		...((import.meta as any)?.electron ? ["electron-main"] : []),
+		...(import.meta.client ? ["client"] : []),
+		...(import.meta.server ? ["server"] : [])
+	]
+	for (const target of additionalServerTransportTargets ?? []) {
+		const contexts = (target as any)._contexts as string[]
+		const contextMatches = contexts === undefined || contexts.find(c => thisContexts.includes(c))
+		if (!contextMatches) continue
+
+		const propPaths = (target as any)._loadFromEnv as string[]
+		// we have to clone because we can't write to runtimeConfig
+		const clone = walk(target, undefined, { 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 as any)._loadFromEnv
+	}
+
+	return {
+		debug: {
+			logPath,
+			writeLevel,
+			logLevel
+		},
+		opts: {
+			redact,
+			// do not under any circumstances change how level looks, it breaks the logging ??? :/
+			level: logLevel,
+			formatters: {
+				bindings: () => ({})
+			},
+			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 as any).electron.api.log(logEvent)
+								}
+							}
+						}
+					: undefined
+			}
+		},
+		transports: {
+			targets: [
+				{
+					level: writeLevel,
+					target: "pino/file",
+					options: {
+						destination: 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 as any).target))
+		}
+	}
+}

package/src/runtime/plugins/init.ts

@@ -0,0 +1,25 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#imports"
+
+import { useLogger } from "../composables/useLogger"
+
+export default defineNuxtPlugin({
+	name: "client-init-log",
+	setup(nuxtApp) {
+		if (import.meta.client) {
+			nuxtApp.hook("app:created", () => {
+				const config = useRuntimeConfig().public
+				const initialLog: any = { appInfo: config.appInfo }
+				if (window.navigator !== undefined) {
+					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/src/runtime/server/middleware/log.ts

@@ -0,0 +1,13 @@
+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/src/runtime/server/plugins/init.ts

@@ -0,0 +1,23 @@
+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/src/runtime/server/tsconfig.json

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

package/src/runtime/server/utils/useServerLogger.ts

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

package/src/runtime/shared/createUseLogger.ts

@@ -0,0 +1,74 @@
+import type { RuntimeConfig } from "nuxt/schema"
+import { type Logger, pino } from "pino"
+
+import { getBaseOptions } from "../helpers/getBaseOptions.js"
+import type { Levels } from "../types.js"
+
+export type BaseLogger = Record<Levels, ((data: any) => void)> & {
+	flush: Logger["flush"]
+}
+const logger: BaseLogger = {} as any
+
+/**
+	* 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 function createUseLogger(
+	rc: () => RuntimeConfig
+) {
+	let initiated = false
+	return function useLogger({
+		redirectTo,
+		redirectAll = true
+	}: {
+		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)
+	} = {}) {
+		const levels: (Levels)[] = ["error", "warn", "debug", "trace", "info", "fatal"] as const
+		// there's a bit of a problem calling useRuntimeConfig/useNuxtApp outside the function
+		// so doing initiated check instead
+		if (!initiated) {
+			initiated = true
+
+			const config = rc().public
+			const { opts, transports, browserOpts, debug } = getBaseOptions(config.logger)
+			let transport: any
+			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: any) => {
+					if (redirectTo === "electron") {
+						if (typeof data === "object" && typeof data.ns === "string" && !data.ns.startsWith("main:")) {
+							if (data.ns.startsWith("renderer:")) {
+								(window as any).electron?.api.log(level, data)
+							} else if (typeof redirectAll === "function" ? redirectAll(level, data) : redirectAll) {
+								data.ns = `renderer:${data.ns}`
+								;(window as any).electron?.api.log(level, data)
+							}
+						}
+					}
+					(pinoLogger as any)[level](data)
+				}
+			}
+			logger.debug({ ns: "log", ...debug, enabledTransportTargets: transports.targets.map(t => (t as any)?.target) })
+			return logger
+		}
+		return logger
+	}
+}

package/src/runtime/types.ts

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