@rivetkit/effect 0.0.0-sqlite-uds.37f9e48 → 0.0.0-sqlite-profiling-compat.87d61c0

package/src/internal/ActorInstanceManager.ts

@@ -77,9 +77,7 @@ export const make = Effect.fnUntraced(function* <
 		const scope = yield* Scope.make();
 		return yield* Effect.gen(function* () {
 			const state = stateAdapter
-				? yield* stateAdapter
-						.makeStateView(c)
-						.pipe(Effect.provideService(Scope.Scope, scope))
+				? yield* stateAdapter.makeStateView(c)
 				: undefined;
 			const context = makeContext(c, scope);
 			const actionHandlers = yield* wakeHandler(
@@ -107,7 +105,15 @@ export const make = Effect.fnUntraced(function* <
 	return {
 		get: (actorId: string) => instances.get(actorId),
 		onWake: async (c: WakeContext<StateDefinition, Database>) => {
-			instances.set(c.actorId, await runPromise(makeInstance(c)));
+			await runPromise(
+				makeInstance(c).pipe(
+					Effect.tap((instance) =>
+						Effect.sync(() => {
+							instances.set(c.actorId, instance);
+						}),
+					),
+				),
+			);
 		},
 		onStateChange: stateAdapter
 			? (

package/src/internal/ActorStateAdapter.ts

@@ -1,11 +1,10 @@
-import { Effect, type Fiber, Schema } from "effect";
+import { Effect, type Fiber, Schema, Semaphore } from "effect";
 import * as State from "../State.ts";
 import type * as StateOptions from "./StateOptions.ts";
 
 export type ActorState<StateDefinition extends StateOptions.Any> = State.State<
 	StateOptions.Decoded<StateDefinition>,
-	Schema.SchemaError,
-	StateOptions.Services<StateDefinition>
+	Schema.SchemaError
 >;
 
 type StateInstance<StateDefinition extends StateOptions.Any> = {
@@ -72,8 +71,15 @@ export const make = Effect.fnUntraced(function* <
 					const state = yield* Effect.fromNullishOr(
 						instance.state,
 					).pipe(Effect.orDie);
-					yield* state[State.RuntimeTypeId].publishEffect(
-						stateCodec.decodeUnknown(newState).pipe(Effect.orDie),
+
+					yield* Semaphore.withPermit(
+						state.semaphore,
+						Effect.gen(function* () {
+							const decoded = yield* stateCodec
+								.decodeUnknown(newState)
+								.pipe(Effect.orDie);
+							State.publishUnsafe(state, decoded);
+						}),
 					);
 				}),
 			);

package/src/internal/StateOptions.ts

@@ -10,10 +10,6 @@ export interface Any {
 	readonly initialValue: () => unknown;
 }
 
-export type Services<State extends Any> =
-	| State["schema"]["DecodingServices"]
-	| State["schema"]["EncodingServices"];
-
 export type Encoded<State extends Any> =
 	| State["schema"]["Encoded"]
 	| ([State] extends [never] ? undefined : never);

package/src/internal/logging.test.ts

@@ -1,6 +1,13 @@
 import { assert, describe, it } from "@effect/vitest";
-import { ConfigProvider, Effect, Logger, References } from "effect";
-import * as RivetkitLog from "rivetkit/log";
+import {
+	Config,
+	ConfigProvider,
+	Effect,
+	Layer,
+	Logger as EffectLogger,
+	References,
+} from "effect";
+import type { Logger as PinoLogger } from "rivetkit/log";
 import * as Logging from "./logging.ts";
 
 type LogEntry = {
@@ -9,7 +16,7 @@ type LogEntry = {
 	readonly msg: string | undefined;
 };
 
-function makeTestLogger(entries: Array<LogEntry>): RivetkitLog.Logger {
+function makeTestLogger(entries: Array<LogEntry>): PinoLogger {
 	const logger: Record<string, unknown> = {};
 	for (const level of ["trace", "debug", "info", "warn", "error", "fatal"]) {
 		logger[level] = (
@@ -20,7 +27,7 @@ function makeTestLogger(entries: Array<LogEntry>): RivetkitLog.Logger {
 		};
 	}
 
-	return logger as unknown as RivetkitLog.Logger;
+	return logger as unknown as PinoLogger;
 }
 
 describe("internal/logging", () => {
@@ -58,21 +65,23 @@ describe("internal/logging", () => {
 					key: "room-1",
 					actorId: "actor-1",
 				}),
-				Effect.provide(Logger.layer([Logging.makeLogger(baseLogger)])),
+				Effect.provide(
+					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
+				),
 			);
 
-			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");
+			assert.deepStrictEqual(entries, [
+				{
+					level: "info",
+					fields: {
+						roomId: "abc",
+						actor: "ChatRoom",
+						key: "room-1",
+						actorId: "actor-1",
+					},
+					msg: "room awake",
+				},
+			]);
 		}),
 	);
 
@@ -83,7 +92,9 @@ describe("internal/logging", () => {
 			const error = new Error("room failed to wake");
 
 			yield* Effect.logError(error).pipe(
-				Effect.provide(Logger.layer([Logging.makeLogger(baseLogger)])),
+				Effect.provide(
+					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
+				),
 			);
 
 			const entry = entries[0];
@@ -104,7 +115,9 @@ describe("internal/logging", () => {
 				actorId: "actor-1",
 				action: "SendMessage",
 			}).pipe(
-				Effect.provide(Logger.layer([Logging.makeLogger(baseLogger)])),
+				Effect.provide(
+					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
+				),
 			);
 
 			const entry = entries[0];
@@ -117,7 +130,17 @@ describe("internal/logging", () => {
 		}),
 	);
 
-	it.effect("accepts RIVET_LOG_LEVEL values", () =>
+	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", () =>
 		Effect.gen(function* () {
 			const baseLogger = yield* Logging.makeDefaultBaseLogger;
 
@@ -134,24 +157,25 @@ describe("internal/logging", () => {
 		),
 	);
 
-	it.effect("accepts uppercase RIVET_LOG_LEVEL values", () =>
+	it.effect("prefers References.MinimumLogLevel over shared env 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: "DEBUG",
+						RIVET_LOG_LEVEL: "silent",
 					},
 				}),
 			),
 		),
 	);
 
-	it.effect("ignores Effect-only RIVET_LOG_LEVEL values", () =>
+	it.effect("preserves an explicit Info minimum log level", () =>
 		Effect.gen(function* () {
 			const baseLogger = yield* Logging.makeDefaultBaseLogger;
 
@@ -162,45 +186,36 @@ describe("internal/logging", () => {
 				ConfigProvider.ConfigProvider,
 				ConfigProvider.fromEnv({
 					env: {
-						RIVET_LOG_LEVEL: "None",
+						RIVET_LOG_LEVEL: "silent",
 					},
 				}),
 			),
 		),
 	);
 
-	it.effect("falls back to References.MinimumLogLevel without env", () =>
-		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: {},
-				}),
-			),
-		),
-	);
-
-	it.effect("RIVET_LOG_LEVEL overrides References.MinimumLogLevel", () =>
-		Effect.gen(function* () {
-			const baseLogger = yield* Logging.makeDefaultBaseLogger;
+	it.effect(
+		"uses Config.logLevel values provided to References.MinimumLogLevel",
+		() =>
+			Effect.gen(function* () {
+				const baseLogger = yield* Logging.makeDefaultBaseLogger;
 
-			assert.strictEqual(baseLogger.level, "silent");
-		}).pipe(
-			Effect.provideService(References.MinimumLogLevel, "Debug"),
-			Effect.provideService(
-				ConfigProvider.ConfigProvider,
-				ConfigProvider.fromEnv({
-					env: {
-						RIVET_LOG_LEVEL: "silent",
-					},
-				}),
+				assert.strictEqual(baseLogger.level, "trace");
+			}).pipe(
+				Effect.provide(
+					Layer.effect(
+						References.MinimumLogLevel,
+						Config.logLevel("RIVET_LOG_LEVEL"),
+					),
+				),
+				Effect.provideService(
+					ConfigProvider.ConfigProvider,
+					ConfigProvider.fromEnv({
+						env: {
+							RIVET_LOG_LEVEL: "Trace",
+						},
+					}),
+				),
 			),
-		),
 	);
 
 	it.effect(
@@ -214,18 +229,19 @@ describe("internal/logging", () => {
 					Effect.provideService(References.CurrentLogLevel, "Debug"),
 					Effect.provideService(References.MinimumLogLevel, "Debug"),
 					Effect.provide(
-						Logger.layer([Logging.makeLogger(baseLogger)]),
+						EffectLogger.layer([
+							Logging.makeEffectLogger(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");
+				assert.deepStrictEqual(entries, [
+					{
+						level: "debug",
+						fields: {},
+						msg: "plain log",
+					},
+				]);
 			}),
 	);
 
@@ -240,7 +256,9 @@ describe("internal/logging", () => {
 					Effect.provideService(References.CurrentLogLevel, "None"),
 					Effect.provideService(References.MinimumLogLevel, "All"),
 					Effect.provide(
-						Logger.layer([Logging.makeLogger(baseLogger)]),
+						EffectLogger.layer([
+							Logging.makeEffectLogger(baseLogger),
+						]),
 					),
 				);
 
@@ -258,13 +276,18 @@ describe("internal/logging", () => {
 				yield* Effect.logInfo("checkout complete").pipe(
 					Effect.withLogSpan("checkout"),
 					Effect.provide(
-						Logger.layer([Logging.makeLogger(baseLogger)]),
+						EffectLogger.layer([
+							Logging.makeEffectLogger(baseLogger),
+						]),
 					),
 				);
 
 				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;

package/src/internal/logging.ts

@@ -1,16 +1,19 @@
 import {
+	Cause,
 	Config,
 	Context,
 	Effect,
-	Logger,
-	Option,
-	Predicate,
-	Record as EffectRecord,
+	Logger as EffectLogger,
 	type LogLevel,
 	References,
 } from "effect";
 import type * as Rivetkit from "rivetkit";
-import * as RivetkitLog from "rivetkit/log";
+import {
+	configureDefaultLogger,
+	getBaseLogger,
+	type Logger as PinoLogger,
+	type LogLevel as PinoLogLevel,
+} from "rivetkit/log";
 
 const EMPTY_KEY = "/";
 const KEY_SEPARATOR = "/";
@@ -21,14 +24,25 @@ type ActorLogContext = {
 	readonly actorId: string;
 };
 
-export class BaseLogger extends Context.Service<
-	BaseLogger,
-	RivetkitLog.Logger
->()("@rivetkit/effect/RivetLogger/BaseLogger") {}
+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",
+};
 
-const RivetkitLogLevels = RivetkitLog.LogLevelSchema.options;
+export const toPinoLevel = (logLevel: LogLevel.LogLevel): PinoLogLevel =>
+	PinoLevelByEffectLevel[logLevel];
 
-const EffectLevelByRivetkitLevel = {
+const EffectLevelByPinoLevel: Record<PinoLogLevel, LogLevel.LogLevel> = {
 	trace: "Trace",
 	debug: "Debug",
 	info: "Info",
@@ -36,54 +50,56 @@ const EffectLevelByRivetkitLevel = {
 	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 rivetLogLevelFromEnv = Config.string("RIVET_LOG_LEVEL").pipe(
-	Effect.option,
-	Effect.map((maybeRivetLogLevel) => {
-		if (Option.isNone(maybeRivetLogLevel)) return Option.none();
+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 parsed = RivetkitLog.LogLevelSchema.safeParse(
-			maybeRivetLogLevel.value.toLowerCase(),
-		);
-		return parsed.success ? Option.some(parsed.data) : Option.none();
+		return "Info";
 	}),
 );
 
-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];
+const logLevelFromEnv = Config.logLevel("RIVET_LOG_LEVEL").pipe(
+	Config.orElse(() => pinoLogLevelFromEnv),
+	Effect.option,
+);
 
-		return yield* Effect.sync(() =>
-			RivetkitLog.makeDefaultLogger(logLevel),
+export const makeDefaultBaseLogger: Effect.Effect<PinoLogger> = Effect.gen(
+	function* () {
+		const context = yield* Effect.context();
+		const providedMinimumLogLevel = Context.getOrUndefined(
+			context,
+			References.MinimumLogLevel,
 		);
-	});
+		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<RivetkitLog.Logger> =
-	Effect.gen(function* () {
-		const maybeBaseLogger = yield* Effect.serviceOption(BaseLogger);
-		if (Option.isSome(maybeBaseLogger)) {
-			return maybeBaseLogger.value;
+export const getOrCreateBaseLogger: Effect.Effect<PinoLogger> = Effect.gen(
+	function* () {
+		const provided = yield* Effect.serviceOption(BaseLogger);
+		if (provided._tag === "Some") {
+			return provided.value;
 		}
 
 		return yield* makeDefaultBaseLogger;
-	});
+	},
+);
 
 export function makeActorLogAnnotations(context: ActorLogContext): {
 	readonly actor: string;
@@ -115,64 +131,59 @@ export function serializeActorKey(key: Rivetkit.ActorKey): string {
 		.join(KEY_SEPARATOR);
 }
 
-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;
-		}
+function structuredValue(value: unknown): unknown {
+	if (value instanceof Error) {
+		return value;
+	}
 
-		const logger = baseLogger[rivetkitLevel];
-		if (msg === undefined) {
-			logger.call(baseLogger, fields);
-		} else {
-			logger.call(baseLogger, fields, msg);
-		}
-	});
+	return value;
 }
 
-function extractMessage(message: unknown): {
+function extractMessageAndFields(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;
 
-	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;
-			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);
+	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 {
-				Object.assign(fields, value);
+				fields[key] = structuredValue(value);
+			}
+		}
+	} else if (first !== undefined) {
+		msg = String(first);
+	}
+
+	const args: Array<unknown> = [];
+	for (const value of rest) {
+		if (value instanceof Error) {
+			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);
 			}
-		} else if (index === 0) {
-			msg = value === undefined ? undefined : String(value);
 		} else {
 			args.push(value);
 		}
@@ -185,13 +196,42 @@ function extractMessage(message: unknown): {
 	return { msg, fields };
 }
 
-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)
-	);
+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);
+		}
+	});
 }

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";