@rivetkit/effect 0.0.0-main.879b6a2 → 0.0.0-sqlite-uds.4e59a38

package/src/internal/logging.test.ts

@@ -1,13 +1,6 @@
 import { assert, describe, it } from "@effect/vitest";
-import {
-	Config,
-	ConfigProvider,
-	Effect,
-	Layer,
-	Logger as EffectLogger,
-	References,
-} from "effect";
-import type { Logger as PinoLogger } from "rivetkit/log";
+import { ConfigProvider, Effect, Logger, References } from "effect";
+import * as RivetkitLog from "rivetkit/log";
 import * as Logging from "./logging.ts";
 
 type LogEntry = {
@@ -16,16 +9,9 @@ type LogEntry = {
 	readonly msg: string | undefined;
 };
 
-function makeTestLogger(entries: Array<LogEntry>): PinoLogger {
+function makeTestLogger(entries: Array<LogEntry>): RivetkitLog.Logger {
 	const logger: Record<string, unknown> = {};
-	for (const level of [
-		"trace",
-		"debug",
-		"info",
-		"warn",
-		"error",
-		"fatal",
-	]) {
+	for (const level of ["trace", "debug", "info", "warn", "error", "fatal"]) {
 		logger[level] = (
 			fields: Record<string, unknown>,
 			msg?: string,
@@ -34,7 +20,7 @@ function makeTestLogger(entries: Array<LogEntry>): PinoLogger {
 		};
 	}
 
-	return logger as unknown as PinoLogger;
+	return logger as unknown as RivetkitLog.Logger;
 }
 
 describe("internal/logging", () => {
@@ -72,23 +58,21 @@ describe("internal/logging", () => {
 					key: "room-1",
 					actorId: "actor-1",
 				}),
-				Effect.provide(
-					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
-				),
+				Effect.provide(Logger.layer([Logging.makeLogger(baseLogger)])),
 			);
 
-			assert.deepStrictEqual(entries, [
-				{
-					level: "info",
-					fields: {
-						roomId: "abc",
-						actor: "ChatRoom",
-						key: "room-1",
-						actorId: "actor-1",
-					},
-					msg: "room awake",
-				},
-			]);
+			const entry = entries[0];
+			assert.ok(entry !== undefined);
+			assert.strictEqual(entry.level, "info");
+			assert.strictEqual(entry.msg, "room awake");
+			assert.deepStrictEqual(entry.fields, {
+				roomId: "abc",
+				actor: "ChatRoom",
+				key: "room-1",
+				actorId: "actor-1",
+				fiberId: entry.fields.fiberId,
+			});
+			assert.strictEqual(typeof entry.fields.fiberId, "string");
 		}),
 	);
 
@@ -99,9 +83,7 @@ describe("internal/logging", () => {
 			const error = new Error("room failed to wake");
 
 			yield* Effect.logError(error).pipe(
-				Effect.provide(
-					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
-				),
+				Effect.provide(Logger.layer([Logging.makeLogger(baseLogger)])),
 			);
 
 			const entry = entries[0];
@@ -122,9 +104,7 @@ describe("internal/logging", () => {
 				actorId: "actor-1",
 				action: "SendMessage",
 			}).pipe(
-				Effect.provide(
-					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
-				),
+				Effect.provide(Logger.layer([Logging.makeLogger(baseLogger)])),
 			);
 
 			const entry = entries[0];
@@ -137,15 +117,7 @@ describe("internal/logging", () => {
 		}),
 	);
 
-	it.effect("uses References.MinimumLogLevel when creating the base logger", () =>
-		Effect.gen(function* () {
-			const baseLogger = yield* Logging.makeDefaultBaseLogger;
-
-			assert.strictEqual(baseLogger.level, "debug");
-		}).pipe(Effect.provideService(References.MinimumLogLevel, "Debug")),
-	);
-
-	it.effect("accepts the shared Pino RIVET_LOG_LEVEL values", () =>
+	it.effect("accepts RIVET_LOG_LEVEL values", () =>
 		Effect.gen(function* () {
 			const baseLogger = yield* Logging.makeDefaultBaseLogger;
 
@@ -162,25 +134,24 @@ describe("internal/logging", () => {
 		),
 	);
 
-	it.effect("prefers References.MinimumLogLevel over shared env values", () =>
+	it.effect("accepts uppercase RIVET_LOG_LEVEL values", () =>
 		Effect.gen(function* () {
 			const baseLogger = yield* Logging.makeDefaultBaseLogger;
 
 			assert.strictEqual(baseLogger.level, "debug");
 		}).pipe(
-			Effect.provideService(References.MinimumLogLevel, "Debug"),
 			Effect.provideService(
 				ConfigProvider.ConfigProvider,
 				ConfigProvider.fromEnv({
 					env: {
-						RIVET_LOG_LEVEL: "silent",
+						RIVET_LOG_LEVEL: "DEBUG",
 					},
 				}),
 			),
 		),
 	);
 
-	it.effect("preserves an explicit Info minimum log level", () =>
+	it.effect("ignores Effect-only RIVET_LOG_LEVEL values", () =>
 		Effect.gen(function* () {
 			const baseLogger = yield* Logging.makeDefaultBaseLogger;
 
@@ -191,98 +162,113 @@ describe("internal/logging", () => {
 				ConfigProvider.ConfigProvider,
 				ConfigProvider.fromEnv({
 					env: {
-						RIVET_LOG_LEVEL: "silent",
+						RIVET_LOG_LEVEL: "None",
 					},
 				}),
 			),
 		),
 	);
 
-	it.effect("uses Config.logLevel values provided to References.MinimumLogLevel", () =>
+	it.effect("falls back to References.MinimumLogLevel without env", () =>
 		Effect.gen(function* () {
 			const baseLogger = yield* Logging.makeDefaultBaseLogger;
 
-			assert.strictEqual(baseLogger.level, "trace");
+			assert.strictEqual(baseLogger.level, "debug");
 		}).pipe(
-			Effect.provide(
-				Layer.effect(
-					References.MinimumLogLevel,
-					Config.logLevel("RIVET_LOG_LEVEL"),
-				),
-			),
+			Effect.provideService(References.MinimumLogLevel, "Debug"),
 			Effect.provideService(
 				ConfigProvider.ConfigProvider,
 				ConfigProvider.fromEnv({
-					env: {
-						RIVET_LOG_LEVEL: "Trace",
-					},
+					env: {},
 				}),
 			),
 		),
 	);
 
-	it.effect("uses References.CurrentLogLevel for plain Effect.log calls", () =>
+	it.effect("RIVET_LOG_LEVEL overrides References.MinimumLogLevel", () =>
 		Effect.gen(function* () {
-			const entries: Array<LogEntry> = [];
-			const baseLogger = makeTestLogger(entries);
-
-			yield* Effect.log("plain log").pipe(
-				Effect.provideService(References.CurrentLogLevel, "Debug"),
-				Effect.provideService(References.MinimumLogLevel, "Debug"),
-				Effect.provide(
-					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
-				),
-			);
+			const baseLogger = yield* Logging.makeDefaultBaseLogger;
 
-			assert.deepStrictEqual(entries, [
-				{
-					level: "debug",
-					fields: {},
-					msg: "plain log",
-				},
-			]);
-		}),
+			assert.strictEqual(baseLogger.level, "silent");
+		}).pipe(
+			Effect.provideService(References.MinimumLogLevel, "Debug"),
+			Effect.provideService(
+				ConfigProvider.ConfigProvider,
+				ConfigProvider.fromEnv({
+					env: {
+						RIVET_LOG_LEVEL: "silent",
+					},
+				}),
+			),
+		),
 	);
 
-	it.effect("does not call a Pino method for the None current log level", () =>
-		Effect.gen(function* () {
-			const entries: Array<LogEntry> = [];
-			const baseLogger = makeTestLogger(entries);
-
-			yield* Effect.log("hidden log").pipe(
-				Effect.provideService(References.CurrentLogLevel, "None"),
-				Effect.provideService(References.MinimumLogLevel, "All"),
-				Effect.provide(
-					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
-				),
-			);
-
-			assert.deepStrictEqual(entries, []);
-		}),
+	it.effect(
+		"uses References.CurrentLogLevel for plain Effect.log calls",
+		() =>
+			Effect.gen(function* () {
+				const entries: Array<LogEntry> = [];
+				const baseLogger = makeTestLogger(entries);
+
+				yield* Effect.log("plain log").pipe(
+					Effect.provideService(References.CurrentLogLevel, "Debug"),
+					Effect.provideService(References.MinimumLogLevel, "Debug"),
+					Effect.provide(
+						Logger.layer([Logging.makeLogger(baseLogger)]),
+					),
+				);
+
+				const entry = entries[0];
+				assert.ok(entry !== undefined);
+				assert.strictEqual(entry.level, "debug");
+				assert.strictEqual(entry.msg, "plain log");
+				assert.deepStrictEqual(entry.fields, {
+					fiberId: entry.fields.fiberId,
+				});
+				assert.strictEqual(typeof entry.fields.fiberId, "string");
+			}),
 	);
 
-	it.effect("emits References.CurrentLogSpans as structured span durations", () =>
-		Effect.gen(function* () {
-			const entries: Array<LogEntry> = [];
-			const baseLogger = makeTestLogger(entries);
-
-			yield* Effect.logInfo("checkout complete").pipe(
-				Effect.withLogSpan("checkout"),
-				Effect.provide(
-					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
-				),
-			);
+	it.effect(
+		"does not call a Pino method for the None current log level",
+		() =>
+			Effect.gen(function* () {
+				const entries: Array<LogEntry> = [];
+				const baseLogger = makeTestLogger(entries);
+
+				yield* Effect.log("hidden log").pipe(
+					Effect.provideService(References.CurrentLogLevel, "None"),
+					Effect.provideService(References.MinimumLogLevel, "All"),
+					Effect.provide(
+						Logger.layer([Logging.makeLogger(baseLogger)]),
+					),
+				);
+
+				assert.deepStrictEqual(entries, []);
+			}),
+	);
 
-			assert.strictEqual(entries.length, 1);
-			assert.strictEqual(entries[0]?.level, "info");
-			assert.strictEqual(entries[0]?.msg, "checkout complete");
-			assert.deepStrictEqual(Object.keys(entries[0]?.fields ?? {}), [
-				"spans",
-			]);
-			const spans = entries[0]?.fields.spans as
-				| Record<string, unknown>
-				| undefined;
-			assert.strictEqual(typeof spans?.checkout, "number");
-		}),
+	it.effect(
+		"emits References.CurrentLogSpans as structured span durations",
+		() =>
+			Effect.gen(function* () {
+				const entries: Array<LogEntry> = [];
+				const baseLogger = makeTestLogger(entries);
+
+				yield* Effect.logInfo("checkout complete").pipe(
+					Effect.withLogSpan("checkout"),
+					Effect.provide(
+						Logger.layer([Logging.makeLogger(baseLogger)]),
+					),
+				);
+
+				assert.strictEqual(entries.length, 1);
+				assert.strictEqual(entries[0]?.level, "info");
+				assert.strictEqual(entries[0]?.msg, "checkout complete");
+				const spans = entries[0]?.fields.spans as
+					| Record<string, unknown>
+					| undefined;
+				assert.strictEqual(typeof spans?.checkout, "number");
+			}),
 	);
 });

package/src/internal/logging.ts

@@ -1,19 +1,16 @@
 import {
-	Cause,
 	Config,
 	Context,
 	Effect,
-	Logger as EffectLogger,
+	Logger,
+	Option,
+	Predicate,
+	Record as EffectRecord,
 	type LogLevel,
 	References,
 } from "effect";
 import type * as Rivetkit from "rivetkit";
-import {
-	configureDefaultLogger,
-	getBaseLogger,
-	type Logger as PinoLogger,
-	type LogLevel as PinoLogLevel,
-} from "rivetkit/log";
+import * as RivetkitLog from "rivetkit/log";
 
 const EMPTY_KEY = "/";
 const KEY_SEPARATOR = "/";
@@ -24,25 +21,14 @@ type ActorLogContext = {
 	readonly actorId: string;
 };
 
-export class BaseLogger extends Context.Service<BaseLogger, PinoLogger>()(
-	"@rivetkit/effect/Logger/BaseLogger",
-) {}
-
-const PinoLevelByEffectLevel: Record<LogLevel.LogLevel, PinoLogLevel> = {
-	All: "trace",
-	Trace: "trace",
-	Debug: "debug",
-	Info: "info",
-	Warn: "warn",
-	Error: "error",
-	Fatal: "fatal",
-	None: "silent",
-};
+export class BaseLogger extends Context.Service<
+	BaseLogger,
+	RivetkitLog.Logger
+>()("@rivetkit/effect/RivetLogger/BaseLogger") {}
 
-export const toPinoLevel = (logLevel: LogLevel.LogLevel): PinoLogLevel =>
-	PinoLevelByEffectLevel[logLevel];
+const RivetkitLogLevels = RivetkitLog.LogLevelSchema.options;
 
-const EffectLevelByPinoLevel: Record<PinoLogLevel, LogLevel.LogLevel> = {
+const EffectLevelByRivetkitLevel = {
 	trace: "Trace",
 	debug: "Debug",
 	info: "Info",
@@ -50,56 +36,54 @@ const EffectLevelByPinoLevel: Record<PinoLogLevel, LogLevel.LogLevel> = {
 	error: "Error",
 	fatal: "Fatal",
 	silent: "None",
-};
+} as const satisfies Record<
+	RivetkitLog.LogLevel,
+	Exclude<LogLevel.LogLevel, "All">
+>;
+
+const RivetkitLevelByEffectLevel = {
+	...Object.fromEntries(
+		RivetkitLogLevels.map((level) => [
+			EffectLevelByRivetkitLevel[level],
+			level,
+		]),
+	),
+	All: "trace",
+} as Record<LogLevel.LogLevel, RivetkitLog.LogLevel>;
 
-const pinoLogLevelFromEnv = Config.string("RIVET_LOG_LEVEL").pipe(
-	Config.map((value) => {
-		const pinoLevel = value.toLowerCase();
-		if (pinoLevel in EffectLevelByPinoLevel) {
-			return EffectLevelByPinoLevel[pinoLevel as PinoLogLevel];
-		}
+const rivetLogLevelFromEnv = Config.string("RIVET_LOG_LEVEL").pipe(
+	Effect.option,
+	Effect.map((maybeRivetLogLevel) => {
+		if (Option.isNone(maybeRivetLogLevel)) return Option.none();
 
-		return "Info";
+		const parsed = RivetkitLog.LogLevelSchema.safeParse(
+			maybeRivetLogLevel.value.toLowerCase(),
+		);
+		return parsed.success ? Option.some(parsed.data) : Option.none();
 	}),
 );
 
-const logLevelFromEnv = Config.logLevel("RIVET_LOG_LEVEL").pipe(
-	Config.orElse(() => pinoLogLevelFromEnv),
-	Effect.option,
-);
+export const makeDefaultBaseLogger: Effect.Effect<RivetkitLog.Logger> =
+	Effect.gen(function* () {
+		const maybeRivetLogLevel = yield* rivetLogLevelFromEnv;
+		const logLevel = Option.isSome(maybeRivetLogLevel)
+			? maybeRivetLogLevel.value
+			: RivetkitLevelByEffectLevel[yield* References.MinimumLogLevel];
 
-export const makeDefaultBaseLogger: Effect.Effect<PinoLogger> = Effect.gen(
-	function* () {
-		const context = yield* Effect.context();
-		const providedMinimumLogLevel = Context.getOrUndefined(
-			context,
-			References.MinimumLogLevel,
+		return yield* Effect.sync(() =>
+			RivetkitLog.makeDefaultLogger(logLevel),
 		);
-		const envLogLevel = yield* logLevelFromEnv;
-		const logLevel =
-			providedMinimumLogLevel !== undefined
-				? providedMinimumLogLevel
-				: envLogLevel._tag === "Some"
-					? envLogLevel.value
-					: yield* References.MinimumLogLevel;
-
-		return yield* Effect.sync(() => {
-			configureDefaultLogger(toPinoLevel(logLevel));
-			return getBaseLogger();
-		});
-	},
-);
+	});
 
-export const getOrCreateBaseLogger: Effect.Effect<PinoLogger> = Effect.gen(
-	function* () {
-		const provided = yield* Effect.serviceOption(BaseLogger);
-		if (provided._tag === "Some") {
-			return provided.value;
+export const getOrCreateBaseLogger: Effect.Effect<RivetkitLog.Logger> =
+	Effect.gen(function* () {
+		const maybeBaseLogger = yield* Effect.serviceOption(BaseLogger);
+		if (Option.isSome(maybeBaseLogger)) {
+			return maybeBaseLogger.value;
 		}
 
 		return yield* makeDefaultBaseLogger;
-	},
-);
+	});
 
 export function makeActorLogAnnotations(context: ActorLogContext): {
 	readonly actor: string;
@@ -131,59 +115,64 @@ export function serializeActorKey(key: Rivetkit.ActorKey): string {
 		.join(KEY_SEPARATOR);
 }
 
-function structuredValue(value: unknown): unknown {
-	if (value instanceof Error) {
-		return value;
-	}
+export function makeLogger(
+	baseLogger: RivetkitLog.Logger,
+): Logger.Logger<unknown, void> {
+	return Logger.make((options) => {
+		if (options.logLevel === "None") return;
+		const rivetkitLevel = RivetkitLevelByEffectLevel[options.logLevel];
+		const structured = Logger.formatStructured.log(options);
+		const { msg, fields: messageFields } = extractMessage(
+			structured.message,
+		);
+		const fields: Record<string, unknown> = {
+			...messageFields,
+			...structured.annotations,
+			fiberId: structured.fiberId,
+		};
+
+		if (!EffectRecord.isEmptyRecord(structured.spans)) {
+			fields.spans = structured.spans;
+		}
+		if (structured.cause !== undefined) {
+			fields.cause = structured.cause;
+		}
 
-	return value;
+		const logger = baseLogger[rivetkitLevel];
+		if (msg === undefined) {
+			logger.call(baseLogger, fields);
+		} else {
+			logger.call(baseLogger, fields, msg);
+		}
+	});
 }
 
-function extractMessageAndFields(message: unknown): {
+function extractMessage(message: unknown): {
 	readonly msg: string | undefined;
 	readonly fields: Record<string, unknown>;
 } {
 	const values = Array.isArray(message) ? message : [message];
-	if (values.length === 0) {
-		return { msg: undefined, fields: {} };
-	}
-
-	const [first, ...rest] = values;
 	const fields: Record<string, unknown> = {};
+	const args: Array<unknown> = [];
 	let msg: string | undefined;
 
-	if (first instanceof Error) {
-		fields.error = first;
-		msg = first.message;
-	} else if (first !== null && typeof first === "object") {
-		const firstFields = first as Record<string, unknown>;
-		for (const [key, value] of Object.entries(firstFields)) {
-			if (key === "msg") {
-				if (value !== undefined) {
-					msg = String(value);
-				}
-			} else {
-				fields[key] = structuredValue(value);
-			}
-		}
-	} else if (first !== undefined) {
-		msg = String(first);
-	}
-
-	const args: Array<unknown> = [];
-	for (const value of rest) {
-		if (value instanceof Error) {
+	for (const [index, value] of values.entries()) {
+		if (Predicate.isError(value)) {
+			fields.error = value;
+			if (index === 0) msg = value.message;
+		} else if (isStructuredError(value)) {
 			fields.error = value;
-		} else if (
-			value !== null &&
-			typeof value === "object" &&
-			!Array.isArray(value)
-		) {
-			for (const [key, fieldValue] of Object.entries(
-				value as Record<string, unknown>,
-			)) {
-				fields[key] = structuredValue(fieldValue);
+			if (index === 0) msg = value.error;
+		} else if (Predicate.isObject(value)) {
+			if (index === 0) {
+				const { msg: valueMsg, ...rest } = value;
+				Object.assign(fields, rest);
+				if (valueMsg !== undefined) msg = String(valueMsg);
+			} else {
+				Object.assign(fields, value);
 			}
+		} else if (index === 0) {
+			msg = value === undefined ? undefined : String(value);
 		} else {
 			args.push(value);
 		}
@@ -196,42 +185,13 @@ function extractMessageAndFields(message: unknown): {
 	return { msg, fields };
 }
 
-export function makeEffectLogger(
-	baseLogger: PinoLogger,
-): EffectLogger.Logger<unknown, void> {
-	return EffectLogger.make(({ cause, date, fiber, logLevel, message }) => {
-		const { msg, fields } = extractMessageAndFields(message);
-
-		for (const [key, value] of Object.entries(
-			fiber.getRef(References.CurrentLogAnnotations),
-		)) {
-			fields[key] = structuredValue(value);
-		}
-
-		const spans: Record<string, number> = {};
-		for (const [label, startTime] of fiber.getRef(
-			References.CurrentLogSpans,
-		)) {
-			spans[label] = date.getTime() - startTime;
-		}
-		if (Object.keys(spans).length > 0) {
-			fields.spans = spans;
-		}
-
-		if (cause.reasons.length > 0) {
-			fields.cause = Cause.pretty(cause);
-		}
-
-		const pinoLevel = toPinoLevel(logLevel);
-		if (pinoLevel === "silent") {
-			return;
-		}
-
-		const logger = baseLogger[pinoLevel];
-		if (msg === undefined) {
-			logger.call(baseLogger, fields);
-		} else {
-			logger.call(baseLogger, fields, msg);
-		}
-	});
+function isStructuredError(
+	value: unknown,
+): value is { readonly error: string; readonly name: string } {
+	return (
+		Predicate.hasProperty(value, "error") &&
+		Predicate.hasProperty(value, "name") &&
+		Predicate.isString(value.error) &&
+		Predicate.isString(value.name)
+	);
 }

package/src/mod.ts

@@ -1,7 +1,7 @@
 export * as Action from "./Action.ts";
 export * as Actor from "./Actor.ts";
 export * as Client from "./Client.ts";
-export * as Logger from "./Logger.ts";
 export * as Registry from "./Registry.ts";
+export * as RivetLogger from "./RivetLogger.ts";
 export * as RivetError from "./RivetError.ts";
 export * as State from "./State.ts";

package/dist/Logger.d.ts

@@ -1,29 +0,0 @@
-import { Layer } from "effect";
-import type { Logger as PinoLogger } from "rivetkit/log";
-import { BaseLogger } from "./internal/logging.ts";
-/**
- * Builds a logging layer from a custom Pino-compatible logger.
- *
- * The layer installs the matching Effect logger and configures the underlying
- * RivetKit TypeScript SDK logs to go through the same logger.
- *
- * @example
- * ```ts
- * import { Logger } from "@rivetkit/effect"
- * import { pino } from "pino"
- *
- * const LoggerLive = Logger.layerPino(
- *   pino({ transport: { target: "pino-pretty" } })
- * )
- * ```
- */
-export declare const layerPino: (baseLogger: PinoLogger) => Layer.Layer<BaseLogger, never, never>;
-/**
- * Default RivetKit Effect logging layer.
- *
- * The layer creates a base logger from `References.MinimumLogLevel` and installs
- * the Effect logger adapter. Applications that want custom formatting or
- * transports should provide {@link layerPino} instead.
- */
-export declare const layer: Layer.Layer<never>;
-//# sourceMappingURL=Logger.d.ts.map

package/dist/Logger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../src/Logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC/D,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EACN,UAAU,EAGV,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,SAAS,GAAI,YAAY,UAAU,0CAO9C,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAEpC,CAAC"}