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

package/src/Client.test.ts

@@ -1,8 +1,12 @@
 import { assert, describe, it } from "@effect/vitest";
-import { Client, RivetError, RivetLogger } from "@rivetkit/effect";
+import { Client, Logger, RivetError } from "@rivetkit/effect";
 import { Effect, Layer, Schema } from "effect";
 import * as RivetkitErrors from "rivetkit/errors";
-import * as RivetkitLog from "rivetkit/log";
+import {
+	configureDefaultLogger,
+	getBaseLogger,
+	type Logger as PinoLogger,
+} from "rivetkit/log";
 import * as ActionErrorEnvelope from "./internal/ActionErrorEnvelope";
 
 function makeTestLogger(
@@ -11,7 +15,7 @@ function makeTestLogger(
 		readonly fields: Record<string, unknown>;
 		readonly msg: string | undefined;
 	}>,
-): RivetkitLog.Logger {
+): PinoLogger {
 	const logger: Record<string, unknown> = {
 		level: "debug",
 		child: () => logger,
@@ -25,7 +29,7 @@ function makeTestLogger(
 		};
 	}
 
-	return logger as unknown as RivetkitLog.Logger;
+	return logger as unknown as PinoLogger;
 }
 
 describe("Client", () => {
@@ -35,15 +39,13 @@ describe("Client", () => {
 				const baseLogger = makeTestLogger();
 
 				yield* Effect.addFinalizer(() =>
-					Effect.sync(() =>
-						RivetkitLog.configureDefaultLogger("silent"),
-					),
+					Effect.sync(() => configureDefaultLogger("silent")),
 				);
 				yield* Client.make({
 					endpoint: "http://127.0.0.1:6420",
-				}).pipe(Effect.provide(RivetLogger.layerFromPino(baseLogger)));
+				}).pipe(Effect.provide(Logger.layerPino(baseLogger)));
 
-				assert.strictEqual(RivetkitLog.getBaseLogger(), baseLogger);
+				assert.strictEqual(getBaseLogger(), baseLogger);
 			}),
 		),
 	);
@@ -59,9 +61,7 @@ describe("Client", () => {
 				const baseLogger = makeTestLogger(entries);
 
 				yield* Effect.addFinalizer(() =>
-					Effect.sync(() =>
-						RivetkitLog.configureDefaultLogger("silent"),
-					),
+					Effect.sync(() => configureDefaultLogger("silent")),
 				);
 				yield* Effect.gen(function* () {
 					yield* Client.Client;
@@ -73,19 +73,16 @@ describe("Client", () => {
 						Client.layer({
 							endpoint: "http://127.0.0.1:6420",
 						}).pipe(
-							Layer.provideMerge(
-								RivetLogger.layerFromPino(baseLogger),
-							),
+							Layer.provideMerge(Logger.layerPino(baseLogger)),
 						),
 					),
 				);
 
-				const entry = entries[0];
-				assert.ok(entry !== undefined);
-				assert.strictEqual(entry.level, "info");
-				assert.strictEqual(entry.msg, "client effect log");
-				assert.strictEqual(entry.fields.clientId, "test-client");
-				assert.strictEqual(typeof entry.fields.fiberId, "string");
+				assert.deepStrictEqual(entries[0], {
+					level: "info",
+					fields: { clientId: "test-client" },
+					msg: "client effect log",
+				});
 				assert.ok(
 					entries.some(
 						(entry) =>

package/src/Client.ts

@@ -1,13 +1,13 @@
 import { Context, Effect, Layer, Record, Result, Schema } from "effect";
 import * as RivetkitClient from "rivetkit/client";
 import * as RivetkitErrors from "rivetkit/errors";
-import * as RivetkitLog from "rivetkit/log";
+import { configureBaseLogger } from "rivetkit/log";
 import type * as Action from "./Action.ts";
 import type * as Actor from "./Actor.ts";
 import * as ActionErrorEnvelope from "./internal/ActionErrorEnvelope.ts";
 import { getOrCreateBaseLogger } from "./internal/logging.ts";
 import { rpcSystem, type TraceMeta } from "./internal/tracing.ts";
-import * as RivetLogger from "./RivetLogger.ts";
+import * as Logger from "./Logger.ts";
 import * as RivetError from "./RivetError.ts";
 
 const TypeId = "~@rivetkit/effect/Client";
@@ -49,9 +49,7 @@ export const make = Effect.fnUntraced(function* (options: Options = {}) {
 	const baseLogger = yield* getOrCreateBaseLogger;
 	const rivetkitClient = yield* Effect.acquireRelease(
 		Effect.sync(() => {
-			// Raw RivetKit clients do not accept a logger in their config,
-			// so install the Effect-selected logger before construction.
-			RivetkitLog.configureBaseLogger(baseLogger);
+			configureBaseLogger(baseLogger);
 			return RivetkitClient.createClient(options);
 		}),
 		(c) => Effect.promise(() => c.dispose()),
@@ -148,7 +146,7 @@ export const layer = (options: Options = {}): Layer.Layer<Client> =>
 	Layer.unwrap(
 		Effect.map(getOrCreateBaseLogger, (baseLogger) =>
 			Layer.effect(Client, make(options)).pipe(
-				Layer.provideMerge(RivetLogger.layerFromPino(baseLogger)),
+				Layer.provideMerge(Logger.layerPino(baseLogger)),
 			),
 		),
 	);

package/src/Logger.ts

@@ -0,0 +1,43 @@
+import { Effect, Logger as EffectLogger, Layer } from "effect";
+import type { Logger as PinoLogger } from "rivetkit/log";
+import {
+	BaseLogger,
+	getOrCreateBaseLogger,
+	makeEffectLogger,
+} 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 const layerPino = (baseLogger: PinoLogger) =>
+	Layer.mergeAll(
+		Layer.succeed(BaseLogger, baseLogger),
+		EffectLogger.layer([
+			EffectLogger.tracerLogger,
+			makeEffectLogger(baseLogger),
+		]),
+	);
+
+/**
+ * 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 const layer: Layer.Layer<never> = Layer.unwrap(
+	Effect.map(getOrCreateBaseLogger, layerPino),
+);

package/src/Registry.test.ts

@@ -1,8 +1,12 @@
 import { assert, describe, it } from "@effect/vitest";
-import { Action, Actor, Registry, RivetLogger } from "@rivetkit/effect";
+import { Action, Actor, Logger, Registry } from "@rivetkit/effect";
 import { Effect, Layer } from "effect";
 import { HttpEffect } from "effect/unstable/http";
-import * as RivetkitLog from "rivetkit/log";
+import {
+	configureDefaultLogger,
+	getBaseLogger,
+	type Logger as PinoLogger,
+} from "rivetkit/log";
 import { vi } from "vitest";
 
 const TestActor = Actor.make("TestActor", {
@@ -24,7 +28,7 @@ const RegistryLive = ActorsLayer.pipe(
 	),
 );
 
-function makeTestLogger(): RivetkitLog.Logger {
+function makeTestLogger(): PinoLogger {
 	const logger: Record<string, unknown> = {
 		level: "debug",
 		child: () => logger,
@@ -33,7 +37,7 @@ function makeTestLogger(): RivetkitLog.Logger {
 		logger[level] = (): void => {};
 	}
 
-	return logger as unknown as RivetkitLog.Logger;
+	return logger as unknown as PinoLogger;
 }
 
 describe("Registry.toWebHandler", () => {
@@ -220,7 +224,7 @@ describe("Registry.toWebHandler", () => {
 	it("uses a custom logger layer for the underlying RivetKit registry", async () => {
 		const baseLogger = makeTestLogger();
 		const CustomLoggerRegistryLive = RegistryLive.pipe(
-			Layer.provide(RivetLogger.layerFromPino(baseLogger)),
+			Layer.provide(Logger.layerPino(baseLogger)),
 		);
 		const { handler, dispose } = Registry.toWebHandler(
 			CustomLoggerRegistryLive,
@@ -232,10 +236,10 @@ describe("Registry.toWebHandler", () => {
 			);
 
 			assert.strictEqual(response.status, 200);
-			assert.strictEqual(RivetkitLog.getBaseLogger(), baseLogger);
+			assert.strictEqual(getBaseLogger(), baseLogger);
 		} finally {
 			await dispose();
-			RivetkitLog.configureDefaultLogger("silent");
+			configureDefaultLogger("silent");
 		}
 	});
 

package/src/Registry.ts

@@ -7,10 +7,10 @@ import {
 	type HttpServerResponse,
 } from "effect/unstable/http";
 import * as Rivetkit from "rivetkit";
-import * as RivetkitLog from "rivetkit/log";
+import { configureBaseLogger, type Logger as PinoLogger } from "rivetkit/log";
 import * as Client from "./Client.ts";
 import { BaseLogger, getOrCreateBaseLogger } from "./internal/logging.ts";
-import * as RivetLogger from "./RivetLogger.ts";
+import * as Logger from "./Logger.ts";
 
 const TypeId = "~@rivetkit/effect/Registry";
 type ServerlessOptions = NonNullable<
@@ -19,7 +19,7 @@ type ServerlessOptions = NonNullable<
 
 export type Options = Pick<
 	Rivetkit.RegistryConfigInput<Rivetkit.RegistryActors>,
-	"endpoint" | "token" | "namespace" | "noWelcome" | "sqlite"
+	"endpoint" | "token" | "namespace" | "noWelcome"
 >;
 
 export interface Registry {
@@ -27,7 +27,7 @@ export interface Registry {
 
 	readonly options: Options;
 
-	readonly baseLogger: RivetkitLog.Logger;
+	readonly baseLogger: PinoLogger;
 
 	readonly rivetkitActors: Map<string, Rivetkit.AnyActorDefinition>;
 }
@@ -35,49 +35,20 @@ export interface Registry {
 export const Registry: Context.Service<Registry, Registry> =
 	Context.Service<Registry>("@rivetkit/effect/Registry");
 
-/**
- * Creates the shared registry that actor layers register into.
- *
- * @remarks
- * Actor layers created with {@link Actor.Actor.toLayer|`Actor.toLayer()`}
- * register into this service. Registry entrypoints such as
- * {@link serve|`Registry.serve()`}, {@link toWebHandler|`Registry.toWebHandler()`},
- * and {@link toHttpEffect|`Registry.toHttpEffect()`} later use the collected
- * actors to create the underlying RivetKit runtime.
- *
- * @param options - RivetKit runtime options shared by the registered actors.
- *
- * @returns A layer that provides the {@link Registry|`Registry.Registry`}
- * service.
- *
- * @example
- * ```ts
- * import { Registry } from "@rivetkit/effect"
- * import { Layer } from "effect"
- *
- * const ActorsLayer = Layer.mergeAll(ChatRoomLive, ModeratorLive)
- *
- * const MainLayer = Registry.serve(ActorsLayer).pipe(
- *   Layer.provide(Registry.layer({ endpoint: "http://127.0.0.1:6420" }))
- * )
- * ```
- *
- * @see {@link serve|`Registry.serve()`} for starting a long-running actor
- * server.
- * @see {@link toWebHandler|`Registry.toWebHandler()`} for Fetch-compatible
- * serverless handlers.
- * @see {@link toHttpEffect|`Registry.toHttpEffect()`} for Effect HTTP handlers.
- */
+const make = (options: Options, baseLogger: PinoLogger): Registry => {
+	return Registry.of({
+		[TypeId]: TypeId,
+		options,
+		baseLogger,
+		rivetkitActors: new Map(),
+	});
+};
+
 export const layer = (options: Options = {}): Layer.Layer<Registry> =>
 	Layer.effect(
 		Registry,
 		Effect.map(getOrCreateBaseLogger, (baseLogger) =>
-			Registry.of({
-				[TypeId]: TypeId,
-				options,
-				baseLogger,
-				rivetkitActors: new Map(),
-			}),
+			make(options, baseLogger),
 		),
 	);
 
@@ -86,53 +57,24 @@ const setupRivetkitRegistry = (
 	options?: {
 		readonly serverless?: ServerlessOptions | undefined;
 	},
-) =>
-	Effect.sync(() =>
-		Rivetkit.setup({
-			use: Object.fromEntries(registry.rivetkitActors),
-			...registry.options,
-			logging: { baseLogger: registry.baseLogger },
-			...(options?.serverless === undefined
-				? {}
-				: { serverless: options.serverless }),
-		}),
-	);
+) => {
+	configureBaseLogger(registry.baseLogger);
+	return Rivetkit.setup({
+		use: Object.fromEntries(registry.rivetkitActors),
+		...registry.options,
+		logging: { baseLogger: registry.baseLogger },
+		...(options?.serverless === undefined
+			? {}
+			: { serverless: options.serverless }),
+	});
+};
 
 /**
- * Serves the actors registered by `actorsLayer`.
- *
- * @remarks
- * Provide this with {@link layer|`Registry.layer()`} at the application root.
- * Building the returned layer evaluates the actor layer, collects its registered
- * actors, and starts the underlying RivetKit runtime using the options from
- * {@link layer|`Registry.layer()`}. Launch the resulting layer with
- * {@link Layer.launch|`Layer.launch()`} to keep the server process alive.
- *
- * @param actorsLayer - A layer containing one or more
- * {@link Actor.Actor.toLayer|`Actor.toLayer()`} registrations.
- *
- * @returns A side-effecting startup layer that requires the
- * {@link Registry|`Registry.Registry`} service and the services required by
- * `actorsLayer`.
- *
- * @example
- * ```ts
- * import { Registry } from "@rivetkit/effect"
- * import { Layer } from "effect"
- *
- * const ActorsLayer = Layer.mergeAll(ChatRoomLive, ModeratorLive)
- *
- * const MainLayer = Registry.serve(ActorsLayer).pipe(
- *   Layer.provide(Registry.layer({ endpoint: "http://127.0.0.1:6420" }))
- * )
- *
- * Layer.launch(MainLayer).pipe(NodeRuntime.runMain);
- * ```
- *
- * @see {@link toWebHandler|`Registry.toWebHandler()`} for Fetch-compatible
- * serverless handlers.
- * @see {@link toHttpEffect|`Registry.toHttpEffect()`} for Effect HTTP handlers.
+ * Runs an actor registration layer against the configured engine.
  *
+ * The actor layer is built in the server layer scope. Registered Rivet Actors
+ * are collected from `Registry`, materialized into a single underlying RivetKit
+ * registry, and started.
  */
 export const serve = <E, R>(
 	actorsLayer: Layer.Layer<never, E, R>,
@@ -140,14 +82,13 @@ export const serve = <E, R>(
 	Layer.effectDiscard(
 		Effect.gen(function* () {
 			const registry = yield* Registry;
+			const baseLogger = registry.baseLogger;
 			yield* Layer.build(
 				actorsLayer.pipe(
-					Layer.provideMerge(
-						RivetLogger.layerFromPino(registry.baseLogger),
-					),
+					Layer.provideMerge(Logger.layerPino(baseLogger)),
 				),
 			);
-			const rivetkitRegistry = yield* setupRivetkitRegistry(registry);
+			const rivetkitRegistry = setupRivetkitRegistry(registry);
 			yield* Effect.sync(() => rivetkitRegistry.start());
 		}),
 	);
@@ -166,7 +107,7 @@ export const test: Layer.Layer<Client.Client, never, Registry> = Layer.effect(
 	Client.Client,
 	Effect.gen(function* () {
 		const registry = yield* Registry;
-		const rivetkitRegistry = yield* setupRivetkitRegistry(registry);
+		const rivetkitRegistry = setupRivetkitRegistry(registry);
 		rivetkitRegistry.config.test = {
 			...rivetkitRegistry.config.test,
 			enabled: true,
@@ -204,21 +145,17 @@ const makeHttpEffect = (
 	registry: Registry,
 	options?: ToHttpEffectOptions,
 ): Effect.Effect<
-	Effect.Effect<
-		HttpServerResponse.HttpServerResponse,
-		HttpServerError.HttpServerError,
-		HttpServerRequest.HttpServerRequest
-	>
-> =>
-	Effect.map(
-		setupRivetkitRegistry(registry, {
-			serverless: options,
-		}),
-		(rivetkitRegistry) =>
-			HttpEffect.fromWebHandler((request) =>
-				rivetkitRegistry.handler(request),
-			),
+	HttpServerResponse.HttpServerResponse,
+	HttpServerError.HttpServerError,
+	HttpServerRequest.HttpServerRequest
+> => {
+	const rivetkitRegistry = setupRivetkitRegistry(registry, {
+		serverless: options,
+	});
+	return HttpEffect.fromWebHandler((request) =>
+		rivetkitRegistry.handler(request),
 	);
+};
 
 export type ToHttpEffectOptions = ServerlessOptions;
 
@@ -242,14 +179,12 @@ export const toHttpEffect = Effect.fnUntraced(function* <E>(
 	Scope.Scope
 > {
 	const context = yield* Layer.build(
-		registryLayer.pipe(Layer.provideMerge(RivetLogger.defaultLayer)),
-	);
-	const httpEffect = yield* makeHttpEffect(
-		Context.get(context, Registry),
-		options,
+		registryLayer.pipe(Layer.provideMerge(Logger.layer)),
 	);
 	// @effect-diagnostics-next-line returnEffectInGen:off
-	return httpEffect.pipe(Effect.provide(context));
+	return makeHttpEffect(Context.get(context, Registry), options).pipe(
+		Effect.provide(context),
+	);
 });
 
 export type ToWebHandlerOptions = ServerlessOptions & {
@@ -286,17 +221,16 @@ export const toWebHandler = <E>(
 	}
 
 	const registryLayerWithLogging = registryLayer.pipe(
-		Layer.provideMerge(RivetLogger.defaultLayer),
+		Layer.provideMerge(Logger.layer),
 	);
 
 	return HttpEffect.toWebHandlerLayerWith(registryLayerWithLogging, {
 		toHandler: (context) =>
-			Effect.map(
+			Effect.succeed(
 				makeHttpEffect(
 					Context.get(context, Registry),
 					serverlessOptions,
-				),
-				(httpEffect) => httpEffect.pipe(Effect.provide(context)),
+				).pipe(Effect.provide(context)),
 			),
 		middleware,
 		memoMap,

package/src/RivetError.test.ts

@@ -121,13 +121,6 @@ describe("RivetError", () => {
 				"actor ready timeout",
 			),
 		);
-		const wakeRetriesExceeded = RivetError.fromUnknown(
-			new RivetkitErrors.RivetError(
-				"guard",
-				"actor_wake_retries_exceeded",
-				"actor wake retries exceeded",
-			),
-		);
 		const tunnelTimeout = RivetError.fromUnknown(
 			new RivetkitErrors.RivetError(
 				"guard",
@@ -144,10 +137,6 @@ describe("RivetError", () => {
 			readyTimeout.reason,
 			RivetError.GuardActorReadyTimeout,
 		);
-		assert.instanceOf(
-			wakeRetriesExceeded.reason,
-			RivetError.GuardActorWakeRetriesExceeded,
-		);
 		assert.instanceOf(
 			tunnelTimeout.reason,
 			RivetError.GuardTunnelMessageTimeout,

package/src/RivetError.ts

@@ -426,38 +426,6 @@ export class GuardActorReadyTimeout extends Schema.TaggedErrorClass<GuardActorRe
 	}
 }
 
-export class GuardActorWakeRetriesExceeded extends Schema.TaggedErrorClass<GuardActorWakeRetriesExceeded>(
-	`${ReasonTypeId}/GuardActorWakeRetriesExceeded`,
-)("GuardActorWakeRetriesExceeded", {
-	cause: Schema.instanceOf(RivetkitErrors.RivetError),
-}) {
-	readonly [ReasonTypeId] = ReasonTypeId;
-	override get message() {
-		return this.cause.message;
-	}
-	get group() {
-		return this.cause.group;
-	}
-	get code() {
-		return this.cause.code;
-	}
-	get metadata() {
-		return this.cause.metadata;
-	}
-	get actor() {
-		return this.cause.actor;
-	}
-	get statusCode() {
-		return this.cause.statusCode;
-	}
-	get public() {
-		return this.cause.public;
-	}
-	get isRetryable(): boolean {
-		return true;
-	}
-}
-
 export class GuardActorRunnerFailed extends Schema.TaggedErrorClass<GuardActorRunnerFailed>(
 	`${ReasonTypeId}/GuardActorRunnerFailed`,
 )("GuardActorRunnerFailed", {
@@ -848,7 +816,6 @@ export type RivetErrorReason =
 	| InvalidEncoding
 	| InvalidRequest
 	| GuardActorReadyTimeout
-	| GuardActorWakeRetriesExceeded
 	| GuardActorRunnerFailed
 	| GuardServiceUnavailable
 	| GuardActorStoppedWhileWaiting
@@ -876,7 +843,6 @@ export const RivetErrorReason: Schema.Union<
 		typeof InvalidEncoding,
 		typeof InvalidRequest,
 		typeof GuardActorReadyTimeout,
-		typeof GuardActorWakeRetriesExceeded,
 		typeof GuardActorRunnerFailed,
 		typeof GuardServiceUnavailable,
 		typeof GuardActorStoppedWhileWaiting,
@@ -903,7 +869,6 @@ export const RivetErrorReason: Schema.Union<
 	InvalidEncoding,
 	InvalidRequest,
 	GuardActorReadyTimeout,
-	GuardActorWakeRetriesExceeded,
 	GuardActorRunnerFailed,
 	GuardServiceUnavailable,
 	GuardActorStoppedWhileWaiting,
@@ -1028,8 +993,6 @@ const reasonByCode: { [key: string]: MakeRivetErrorReason | undefined } = {
 	"request.invalid": (error) => new InvalidRequest({ cause: error }),
 	"guard.actor_ready_timeout": (error) =>
 		new GuardActorReadyTimeout({ cause: error }),
-	"guard.actor_wake_retries_exceeded": (error) =>
-		new GuardActorWakeRetriesExceeded({ cause: error }),
 	"guard.actor_runner_failed": (error) =>
 		new GuardActorRunnerFailed({ cause: error }),
 	"guard.service_unavailable": (error) =>