rivetkit 2.0.3 → 2.0.5

package/src/common/inline-websocket-adapter2.ts

@@ -7,10 +7,8 @@ import type {
 } from "@/common/websocket-interface";
 import { getLogger } from "./log";
 
-export const LOGGER_NAME = "fake-event-source2";
-
 export function logger() {
-	return getLogger(LOGGER_NAME);
+	return getLogger("fake-event-source2");
 }
 
 // TODO: Merge with ConnectWebSocketOutput interface
@@ -55,11 +53,11 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 		this.#wsContext = new WSContext({
 			raw: this,
 			send: (data: string | ArrayBuffer | Uint8Array) => {
-				logger().debug("WSContext.send called");
+				logger().debug({ msg: "WSContext.send called" });
 				this.#handleMessage(data);
 			},
 			close: (code?: number, reason?: string) => {
-				logger().debug("WSContext.close called", { code, reason });
+				logger().debug({ msg: "WSContext.close called", code, reason });
 				this.#handleClose(code || 1000, reason || "");
 			},
 			// Set readyState to 1 (OPEN) since handlers expect an open connection
@@ -99,11 +97,12 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 	}
 
 	send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {
-		logger().debug("send called", { readyState: this.readyState });
+		logger().debug({ msg: "send called", readyState: this.readyState });
 
 		if (this.readyState !== this.OPEN) {
 			const error = new Error("WebSocket is not open");
-			logger().warn("cannot send message, websocket not open", {
+			logger().warn({
+				msg: "cannot send message, websocket not open",
 				readyState: this.readyState,
 				dataType: typeof data,
 				dataLength: typeof data === "string" ? data.length : "binary",
@@ -124,7 +123,7 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 			return;
 		}
 
-		logger().debug("closing fake websocket", { code, reason });
+		logger().debug({ msg: "closing fake websocket", code, reason });
 
 		this.#readyState = this.CLOSING;
 
@@ -132,7 +131,7 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 		try {
 			this.#handler.onClose({ code, reason, wasClean: true }, this.#wsContext);
 		} catch (err) {
-			logger().error("error closing websocket", { error: err });
+			logger().error({ msg: "error closing websocket", error: err });
 		} finally {
 			this.#readyState = this.CLOSED;
 
@@ -156,15 +155,15 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 	 */
 	async #initialize(): Promise<void> {
 		try {
-			logger().debug("fake websocket initializing");
+			logger().debug({ msg: "fake websocket initializing" });
 
 			// Call the handler's onOpen method
-			logger().debug("calling handler.onOpen with WSContext");
+			logger().debug({ msg: "calling handler.onOpen with WSContext" });
 			this.#handler.onOpen(undefined, this.#wsContext);
 
 			// Update the ready state and fire events
 			this.#readyState = this.OPEN;
-			logger().debug("fake websocket initialized and now OPEN");
+			logger().debug({ msg: "fake websocket initialized and now OPEN" });
 
 			// Fire the open event
 			this.#fireOpen();
@@ -172,13 +171,15 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 			// Delay processing queued messages slightly to allow event handlers to be set up
 			if (this.#queuedMessages.length > 0) {
 				if (this.readyState !== this.OPEN) {
-					logger().warn("socket no longer open, dropping queued messages");
+					logger().warn({
+						msg: "socket no longer open, dropping queued messages",
+					});
 					return;
 				}
 
-				logger().debug(
-					`now processing ${this.#queuedMessages.length} queued messages`,
-				);
+				logger().debug({
+					msg: `now processing ${this.#queuedMessages.length} queued messages`,
+				});
 
 				// Create a copy to avoid issues if new messages arrive during processing
 				const messagesToProcess = [...this.#queuedMessages];
@@ -186,12 +187,13 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 
 				// Process each queued message
 				for (const message of messagesToProcess) {
-					logger().debug("processing queued message");
+					logger().debug({ msg: "processing queued message" });
 					this.#handleMessage(message);
 				}
 			}
 		} catch (err) {
-			logger().error("error opening fake websocket", {
+			logger().error({
+				msg: "error opening fake websocket",
 				error: err,
 				errorMessage: err instanceof Error ? err.message : String(err),
 				stack: err instanceof Error ? err.stack : undefined,
@@ -207,7 +209,8 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 	#handleMessage(data: string | ArrayBuffer | Uint8Array): void {
 		// Store messages that arrive before the socket is fully initialized
 		if (this.readyState !== this.OPEN) {
-			logger().debug("message received before socket is OPEN, queuing", {
+			logger().debug({
+				msg: "message received before socket is OPEN, queuing",
 				readyState: this.readyState,
 				dataType: typeof data,
 				dataLength:
@@ -226,7 +229,8 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 		}
 
 		// Log message received from server
-		logger().debug("fake websocket received message from server", {
+		logger().debug({
+			msg: "fake websocket received message from server",
 			dataType: typeof data,
 			dataLength:
 				typeof data === "string"
@@ -299,11 +303,16 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 				try {
 					listener(event);
 				} catch (err) {
-					logger().error(`error in ${type} event listener`, { error: err });
+					logger().error({
+						msg: `error in ${type} event listener`,
+						error: err,
+					});
 				}
 			}
 		} else {
-			logger().debug(`no ${type} listeners registered, buffering event`);
+			logger().debug({
+				msg: `no ${type} listeners registered, buffering event`,
+			});
 			this.#bufferedEvents.push({ type, event });
 		}
 
@@ -314,7 +323,7 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 					try {
 						this.#onopen(event);
 					} catch (error) {
-						logger().error("error in onopen handler", { error });
+						logger().error({ msg: "error in onopen handler", error });
 					}
 				}
 				break;
@@ -323,7 +332,7 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 					try {
 						this.#onclose(event);
 					} catch (error) {
-						logger().error("error in onclose handler", { error });
+						logger().error({ msg: "error in onclose handler", error });
 					}
 				}
 				break;
@@ -332,7 +341,7 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 					try {
 						this.#onerror(event);
 					} catch (error) {
-						logger().error("error in onerror handler", { error });
+						logger().error({ msg: "error in onerror handler", error });
 					}
 				}
 				break;
@@ -341,7 +350,7 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 					try {
 						this.#onmessage(event);
 					} catch (error) {
-						logger().error("error in onmessage handler", { error });
+						logger().error({ msg: "error in onmessage handler", error });
 					}
 				}
 				break;
@@ -377,7 +386,7 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 
 			this.#dispatchEvent("open", event);
 		} catch (err) {
-			logger().error("error in open event", { error: err });
+			logger().error({ msg: "error in open event", error: err });
 		}
 	}
 
@@ -385,7 +394,7 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 		try {
 			this.#dispatchEvent("close", event);
 		} catch (err) {
-			logger().error("error in close event", { error: err });
+			logger().error({ msg: "error in close event", error: err });
 		}
 	}
 
@@ -402,11 +411,11 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 
 			this.#dispatchEvent("error", event);
 		} catch (err) {
-			logger().error("error in error event", { error: err });
+			logger().error({ msg: "error in error event", error: err });
 		}
 
 		// Log the error
-		logger().error("websocket error", { error });
+		logger().error({ msg: "websocket error", error });
 	}
 
 	// Event handler properties with getters/setters

package/src/common/log.ts

@@ -1,139 +1,214 @@
-import { getEnvUniversal } from "@/utils";
 import {
-	type LevelIndex,
-	LevelNameMap,
-	type LogLevel,
-	LogLevels,
-} from "./log-levels";
+	type LevelWithSilent,
+	type Logger,
+	pino,
+	stdTimeFunctions,
+} from "pino";
+import { z } from "zod";
+import { getEnvUniversal } from "@/utils";
 import {
 	castToLogValue,
 	formatTimestamp,
-	type LogEntry,
+	LOGGER_CONFIG,
 	stringify,
 } from "./logfmt";
 
-interface LogRecord {
-	args: unknown[];
-	datetime: Date;
-	level: number;
-	levelName: string;
-	loggerName: string;
-	msg: string;
-}
+export type { Logger } from "pino";
 
-export class Logger {
-	name: string;
-	level: LogLevel;
+let baseLogger: Logger | undefined;
+let configuredLogLevel: LogLevel | undefined;
 
-	constructor(name: string, level: LogLevel) {
-		this.name = name;
-		this.level = level;
-	}
+/** Cache of child loggers by logger name. */
+const loggerCache = new Map<string, Logger>();
 
-	log(level: LevelIndex, message: string, ...args: unknown[]): void {
-		const record: LogRecord = {
-			msg: message,
-			args,
-			level,
-			loggerName: this.name,
-			datetime: new Date(),
-			levelName: LevelNameMap[level],
-		};
-
-		if (this.#shouldLog(level)) {
-			this.#logRecord(record);
-		}
-	}
+export const LogLevelSchema = z.enum([
+	"trace",
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fatal",
+	"silent",
+]);
 
-	#shouldLog(level: LevelIndex): boolean {
-		return level >= LogLevels[this.level];
-	}
+export type LogLevel = z.infer<typeof LogLevelSchema>;
 
-	#logRecord(record: LogRecord): void {
-		console.log(formatter(record));
+export function getPinoLevel(logLevel?: LogLevel): LevelWithSilent {
+	// Priority: provided > configured > env > default
+	if (logLevel) {
+		return logLevel;
 	}
 
-	trace(message: string, ...args: unknown[]): void {
-		this.log(LogLevels.TRACE, message, ...args);
+	if (configuredLogLevel) {
+		return configuredLogLevel;
 	}
 
-	debug(message: string, ...args: unknown[]): void {
-		this.log(LogLevels.DEBUG, message, ...args);
+	const raw = (getEnvUniversal("LOG_LEVEL") || "warn").toString().toLowerCase();
+
+	const parsed = LogLevelSchema.safeParse(raw);
+	if (parsed.success) {
+		return parsed.data;
 	}
 
-	info(message: string, ...args: unknown[]): void {
-		this.log(LogLevels.INFO, message, ...args);
+	// Default to info if invalid
+	return "info";
+}
+
+export function getIncludeTarget(): boolean {
+	return getEnvUniversal("LOG_TARGET") === "1";
+}
+
+/**
+ * Configure a custom base logger.
+ */
+export function configureBaseLogger(logger: Logger): void {
+	baseLogger = logger;
+	loggerCache.clear();
+}
+
+// TODO: This can be simplified in logfmt.ts
+function customWrite(level: string, o: any) {
+	const entries: any = {};
+
+	// Add timestamp if enabled
+	if (getEnvUniversal("LOG_TIMESTAMP") === "1" && o.time) {
+		const date = typeof o.time === "number" ? new Date(o.time) : new Date();
+		entries.ts = formatTimestamp(date);
 	}
 
-	warn(message: string, ...args: unknown[]): void {
-		this.log(LogLevels.WARN, message, ...args);
+	// Add level
+	entries.level = level.toUpperCase();
+
+	// Add target if present
+	if (o.target) {
+		entries.target = o.target;
 	}
 
-	error(message: string, ...args: unknown[]): void {
-		this.log(LogLevels.ERROR, message, ...args);
+	// Add message
+	if (o.msg) {
+		entries.msg = o.msg;
 	}
 
-	critical(message: string, ...args: unknown[]): void {
-		this.log(LogLevels.CRITICAL, message, ...args);
+	// Add other properties
+	for (const [key, value] of Object.entries(o)) {
+		if (
+			key !== "time" &&
+			key !== "level" &&
+			key !== "target" &&
+			key !== "msg" &&
+			key !== "pid" &&
+			key !== "hostname"
+		) {
+			entries[key] = castToLogValue(value);
+		}
 	}
+
+	const output = stringify(entries);
+	console.log(output);
 }
 
-const loggers: Record<string, Logger> = {};
+/**
+ * Configure the default logger with optional log level.
+ */
+export async function configureDefaultLogger(
+	logLevel?: LogLevel,
+): Promise<void> {
+	// Store the configured log level
+	if (logLevel) {
+		configuredLogLevel = logLevel;
+	}
 
-export function getLogger(name = "default"): Logger {
-	const defaultLogLevelEnv: LogLevel | undefined = getEnvUniversal(
-		"_LOG_LEVEL",
-	) as LogLevel | undefined;
+	baseLogger = pino({
+		level: getPinoLevel(logLevel),
+		messageKey: "msg",
+		// Do not include pid/hostname in output
+		base: {},
+		// Keep a string level in the output
+		formatters: {
+			level(_label: string, number: number) {
+				return { level: number };
+			},
+		},
+		timestamp:
+			getEnvUniversal("LOG_TIMESTAMP") === "1"
+				? stdTimeFunctions.epochTime
+				: false,
+		browser: {
+			write: {
+				fatal: customWrite.bind(null, "fatal"),
+				error: customWrite.bind(null, "error"),
+				warn: customWrite.bind(null, "warn"),
+				info: customWrite.bind(null, "info"),
+				debug: customWrite.bind(null, "debug"),
+				trace: customWrite.bind(null, "trace"),
+			},
+		},
+		hooks: {
+			logMethod(inputArgs, _method, level) {
+				// TODO: This is a hack to not implement our own transport target. We can get better perf if we have our own transport target.
+
+				const levelMap: Record<number, string> = {
+					10: "trace",
+					20: "debug",
+					30: "info",
+					40: "warn",
+					50: "error",
+					60: "fatal",
+				};
+				const levelName = levelMap[level] || "info";
+				const time =
+					getEnvUniversal("LOG_TIMESTAMP") === "1" ? Date.now() : undefined;
+				// TODO: This can be simplified in logfmt.ts
+				if (inputArgs.length >= 2) {
+					const [objOrMsg, msg] = inputArgs;
+					if (typeof objOrMsg === "object" && objOrMsg !== null) {
+						customWrite(levelName, { ...objOrMsg, msg, time });
+					} else {
+						customWrite(levelName, { msg: String(objOrMsg), time });
+					}
+				} else if (inputArgs.length === 1) {
+					const [objOrMsg] = inputArgs;
+					if (typeof objOrMsg === "object" && objOrMsg !== null) {
+						customWrite(levelName, { ...objOrMsg, time });
+					} else {
+						customWrite(levelName, { msg: String(objOrMsg), time });
+					}
+				}
+			},
+		},
+	});
+
+	loggerCache.clear();
+}
 
-	const defaultLogLevel: LogLevel = defaultLogLevelEnv ?? "INFO";
-	if (!loggers[name]) {
-		loggers[name] = new Logger(name, defaultLogLevel);
+/**
+ * Get or initialize the base logger.
+ */
+export function getBaseLogger(): Logger {
+	if (!baseLogger) {
+		configureDefaultLogger();
 	}
-	return loggers[name];
+	return baseLogger!;
 }
 
-function formatter(log: LogRecord): string {
-	const args: LogEntry[] = [];
-	for (let i = 0; i < log.args.length; i++) {
-		const logArg = log.args[i];
-		if (logArg && typeof logArg === "object") {
-			// Spread object
-			for (const k in logArg) {
-				// biome-ignore lint/suspicious/noExplicitAny: Unknown type
-				const v = (logArg as any)[k];
-
-				pushArg(k, v, args);
-			}
-		} else {
-			pushArg(`arg${i}`, logArg, args);
-		}
+/**
+ * Returns a child logger with `target` bound for the given name.
+ */
+export function getLogger(name = "default"): Logger {
+	// Check cache first
+	const cached = loggerCache.get(name);
+	if (cached) {
+		return cached;
 	}
 
-	const logTs = getEnvUniversal("_LOG_TIMESTAMP") === "1";
-	const logTarget = getEnvUniversal("_LOG_TARGET") === "1";
+	// Create
+	const base = getBaseLogger();
 
-	return stringify(
-		...(logTs ? [["ts", formatTimestamp(new Date())] as LogEntry] : []),
-		["level", LevelNameMap[log.level]],
-		...(logTarget ? [["target", log.loggerName] as LogEntry] : []),
-		["msg", log.msg],
-		...args,
-	);
-}
+	// Add target to log if enabled
+	const child = getIncludeTarget() ? base.child({ target: name }) : base;
 
-function pushArg(k: string, v: unknown, args: LogEntry[]) {
-	args.push([k, castToLogValue(v)]);
-}
+	// Cache the logger
+	loggerCache.set(name, child);
 
-// function getEnv(name: string): string | undefined {
-// 	if (typeof window !== "undefined" && window.localStorage) {
-// 		return window.localStorage.getItem(name) || undefined;
-// 	}
-// 	return undefined;
-// 	// TODO(ACTR-9): Add back env config once node compat layer works
-// 	//return crossGetEnv(name);
-// }
-
-export function setupLogging() {
-	// Do nothing for now
+	return child;
 }

package/src/common/logfmt.ts

@@ -1,8 +1,5 @@
 import { type LogLevel, LogLevels } from "./log-levels";
 
-export type LogEntry = [string, LogValue];
-export type LogValue = string | number | bigint | boolean | null | undefined;
-
 const LOG_LEVEL_COLORS: Record<number, string> = {
 	[LogLevels.CRITICAL]: "\x1b[31m", // Red
 	[LogLevels.ERROR]: "\x1b[31m", // Red
@@ -15,9 +12,7 @@ const LOG_LEVEL_COLORS: Record<number, string> = {
 const RESET_COLOR = "\x1b[0m";
 
 /**
- * Serializes logfmt line using orderer parameters.
- *
- * We use varargs because it's ordered & it has less overhead than an object.
+ * Serializes logfmt line from an object.
  *
  * ## Styling Methodology
  *
@@ -31,11 +26,12 @@ const RESET_COLOR = "\x1b[0m";
  * name quickly then look closer to read the data associated with the
  * property.
  */
-export function stringify(...data: LogEntry[]) {
+export function stringify(data: any) {
 	let line = "";
+	const entries = Object.entries(data);
 
-	for (let i = 0; i < data.length; i++) {
-		const [key, valueRaw] = data[i];
+	for (let i = 0; i < entries.length; i++) {
+		const [key, valueRaw] = entries[i];
 
 		let isNull = false;
 		let valueString: string;
@@ -84,7 +80,7 @@ export function stringify(...data: LogEntry[]) {
 			line += `${key}=${valueString}`;
 		}
 
-		if (i !== data.length - 1) {
+		if (i !== entries.length - 1) {
 			line += " ";
 		}
 	}
@@ -104,7 +100,7 @@ export function formatTimestamp(date: Date): string {
 	return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${milliseconds}Z`;
 }
 
-export function castToLogValue(v: unknown): LogValue {
+export function castToLogValue(v: unknown): any {
 	if (
 		typeof v === "string" ||
 		typeof v === "number" ||
@@ -143,10 +139,7 @@ export const LOGGER_CONFIG: GlobalLoggerConfig = {
 /**
  * Converts an object in to an easier to read KV of entries.
  */
-export function spreadObjectToLogEntries(
-	base: string,
-	data: unknown,
-): LogEntry[] {
+export function spreadObjectToLogEntries(base: string, data: unknown): any {
 	if (
 		LOGGER_CONFIG.enableSpreadObject &&
 		typeof data === "object" &&
@@ -155,12 +148,11 @@ export function spreadObjectToLogEntries(
 		Object.keys(data).length !== 0 &&
 		Object.keys(data).length < 16
 	) {
-		const logData: LogEntry[] = [];
+		const logData: any = {};
 		for (const key in data) {
-			// logData.push([`${base}.${key}`, JSON.stringify((data as any)[key])]);
-
-			logData.push(
-				...spreadObjectToLogEntries(
+			Object.assign(
+				logData,
+				spreadObjectToLogEntries(
 					`${base}.${key}`,
 					// biome-ignore lint/suspicious/noExplicitAny: FIXME
 					(data as any)[key],
@@ -170,21 +162,20 @@ export function spreadObjectToLogEntries(
 		return logData;
 	}
 
-	return [[base, JSON.stringify(data)]];
+	return { [base]: JSON.stringify(data) };
 }
 
-export function errorToLogEntries(base: string, error: unknown): LogEntry[] {
+export function errorToLogEntries(base: string, error: unknown): any {
 	if (error instanceof Error) {
-		return [
-			//[`${base}.name`, error.name],
-			[`${base}.message`, error.message],
+		return {
+			[`${base}.message`]: error.message,
 			...(LOGGER_CONFIG.enableErrorStack && error.stack
-				? [[`${base}.stack`, formatStackTrace(error.stack)] as LogEntry]
-				: []),
-			...(error.cause ? errorToLogEntries(`${base}.cause`, error.cause) : []),
-		];
+				? { [`${base}.stack`]: formatStackTrace(error.stack) }
+				: {}),
+			...(error.cause ? errorToLogEntries(`${base}.cause`, error.cause) : {}),
+		};
 	}
-	return [[base, `${error}`]];
+	return { [base]: `${error}` };
 }
 
 // export function errorToLogEntries(base: string, error: unknown): LogEntry[] {