effect-vercel 0.5.0 → 0.7.0

package/README.md

@@ -13,6 +13,8 @@ import * as AiGateway from "effect-vercel/AiGateway"
 | `effect-vercel/AiGatewayCredentials` | How AI Gateway requests authenticate                                            |
 | `effect-vercel/Functions`            | Bindings for `@vercel/functions`: `waitUntil`                                   |
 | `effect-vercel/Oidc`                 | The OIDC token Vercel issues to a deployment                                    |
+| `effect-vercel/Otlp`                 | Keeps a Function running until its OTLP telemetry is exported                   |
+| `effect-vercel/PgClient`             | `@effect/sql-pg` pool that doesn't leave connections open on frozen instances   |
 | `effect-vercel/RuntimeCache`         | [Runtime Cache](https://vercel.com/docs/runtime-cache) for Effect `Persistence` |
 
 ## Install
@@ -21,6 +23,7 @@ import * as AiGateway from "effect-vercel/AiGateway"
 pnpm add effect-vercel effect
 pnpm add @effect/ai-anthropic   # only for effect-vercel/AiGateway
 pnpm add @vercel/functions      # only for effect-vercel/Functions and RuntimeCache
+pnpm add @effect/sql-pg         # only for effect-vercel/PgClient
 ```
 
 ## AI Gateway
@@ -144,6 +147,92 @@ const handler = Effect.gen(function* () {
 - Vercel stops the work when the Function reaches its maximum duration.
 - Off Vercel, `waitUntil` does nothing and the fiber runs in the background.
 
+## OTLP
+
+Effect's OTLP exporters buffer spans, logs and metrics and export them on an interval. Vercel can
+suspend the instance once the response is sent, so the interval may never fire and the telemetry
+is lost. `effect-vercel/Otlp` flushes the exporters when each request ends and keeps the Function
+running until the flush is done.
+
+For an `HttpRouter` app, add the `flushAfterRequest` middleware next to your routes. Provide the
+OTLP layer with `Layer.provideMerge`, so its tracer and logger reach each request:
+
+```ts
+import * as VercelOtlp from "effect-vercel/Otlp"
+import { Layer } from "effect"
+import { FetchHttpClient, HttpRouter } from "effect/http"
+import { Otlp } from "effect/observability"
+
+const { handler } = HttpRouter.toWebHandler(
+  Layer.merge(Routes, VercelOtlp.flushAfterRequest).pipe(
+    Layer.provideMerge(Otlp.layerJson({ baseUrl, resource })),
+    Layer.provide(FetchHttpClient.layer),
+  ),
+)
+```
+
+For another entry point, such as a queue consumer, run `VercelOtlp.flushOnClose` at the start of
+the request in a scope that closes when the request ends:
+
+```ts
+// `services` holds the app's services, including the OTLP layer's Flusher.
+const runSync = Effect.runSyncWith(services)
+const scope = runSync(Scope.make())
+runSync(VercelOtlp.flushOnClose.pipe(Scope.provide(scope)))
+
+// When the request ends:
+runSync(Scope.close(scope, Exit.void))
+```
+
+- The flush starts when the request's scope closes. For an `HttpRouter` app, that is after the
+  response body is sent, so telemetry recorded while a body streams is included.
+- Every request flushes, sampled or not, since logs and metrics are exported either way. Spans and
+  logs are sent only when some are buffered. Metrics send a snapshot on every flush.
+- The Function waits for the flush for at most 2 seconds.
+- Both need the `OtlpExporter.Flusher` that the OTLP layers provide, so leaving them out fails to
+  compile.
+- They register the wait with Vercel when the request starts, while its context is current. Run
+  `flushOnClose` first in its scope, so finalizers added later, such as ending a span, run before
+  the flush.
+- `flush` can't wait for an export the interval already started, and skips exporters disabled
+  after a failure.
+- Off Vercel, or outside a request, they do nothing and the exporters' interval sends the
+  telemetry.
+
+## Postgres
+
+`PgClient.layer` is `PgClient.layer` from `@effect/sql-pg` that keeps the Function instance up
+until the pool has closed its connections.
+
+Vercel freezes an instance once no request or `waitUntil` promise is left. A frozen instance
+keeps its sockets open, so a pooler like PgBouncer still counts them against `max_client_conn`.
+During a deploy many instances freeze at once, which can use up the limit. `attachDatabasePool`
+from `@vercel/functions` handles this for node-postgres pools by waiting out the idle timeout
+after each release. It doesn't support the Effect pool, which also closes an idle connection up
+to twice its `idleTimeout` after its last use.
+
+```ts
+import * as PgClient from "effect-vercel/PgClient"
+import { Redacted } from "effect"
+
+const SqlLive = PgClient.layer({
+  url: Redacted.make(process.env.DATABASE_URL!),
+  maxConnections: 3,
+  idleTimeout: "5 seconds",
+})
+```
+
+- It takes the same config as `@effect/sql-pg`, except `stream`: it opens each socket itself
+  and counts it until it closes. While a socket is open, one `waitUntil` promise keeps the
+  instance up.
+- Each time a request takes a connection from the pool, the promise moves to that request, so a
+  busy instance never keeps a finished request open. The wait also ends a second before the
+  request's deadline.
+- It moves the promise from `onAcquire`. An `onAcquire` in your config still runs, after.
+- Keep `idleTimeout` short. The instance stays up until the pool closes its last idle
+  connection.
+- Off Vercel, it behaves like the plain layer.
+
 ## Runtime Cache
 
 `RuntimeCache.layer` provides Effect's `Persistence`, stored in the Vercel Runtime Cache.

package/dist/Otlp.d.ts

@@ -0,0 +1,25 @@
+import { Effect, Layer, Scope } from "effect";
+import { HttpRouter } from "effect/http";
+import { OtlpExporter } from "effect/observability";
+//#region src/Otlp.d.ts
+/**
+ * When the current scope closes, flushes the OTLP exporters and keeps the
+ * Function running until the flush ends, for at most 2 seconds.
+ *
+ * It registers the wait with Vercel right away, so run it while the request
+ * is current. Run it first in the scope: finalizers added later, such as
+ * ending a span, run before the flush. Off Vercel, or outside a request, it
+ * does nothing, and the exporters' interval sends the telemetry.
+ *
+ * Use `flushAfterRequest` for an `HttpRouter` app. Use this one when the
+ * request has another entry point, with a scope that closes when it ends.
+ */
+export declare const flushOnClose: Effect.Effect<void, never, OtlpExporter.Flusher | Scope.Scope>;
+/**
+ * Global `HttpRouter` middleware that runs `flushOnClose` in each request's
+ * scope. That scope closes after the response body is sent, so telemetry
+ * recorded while a body streams is in the flush.
+ */
+export declare const flushAfterRequest: Layer.Layer<never, never, HttpRouter.HttpRouter | OtlpExporter.Flusher>;
+//#endregion
+//# sourceMappingURL=Otlp.d.ts.map

package/dist/Otlp.js

@@ -0,0 +1,59 @@
+import { t as currentRequest } from "./requestContext-CEUKYTim.js";
+import { Effect } from "effect";
+import { HttpRouter } from "effect/http";
+import { OtlpExporter } from "effect/observability";
+//#region src/Otlp.ts
+/**
+* Keeps a Vercel Function running until its OTLP telemetry is exported.
+*
+* Effect's OTLP exporters buffer spans, logs and metrics and export them on
+* an interval. Vercel can suspend the instance once the response is sent, so
+* the interval may never fire and the telemetry is lost. These flush the
+* exporters when a request ends and keep the Function running until the
+* flush is done.
+*
+* @example
+* ```ts
+* import * as VercelOtlp from "effect-vercel/Otlp"
+* import { Layer } from "effect"
+* import { FetchHttpClient, HttpRouter } from "effect/http"
+* import { Otlp } from "effect/observability"
+*
+* const { handler } = HttpRouter.toWebHandler(
+*   Layer.merge(Routes, VercelOtlp.flushAfterRequest).pipe(
+*     Layer.provideMerge(Otlp.layerJson({ baseUrl, resource })),
+*     Layer.provide(FetchHttpClient.layer),
+*   ),
+* )
+* ```
+*/
+const flushOnCloseWith = (flusher) => Effect.suspend(() => {
+	const request = currentRequest();
+	if (request?.waitUntil === void 0) return Effect.void;
+	const { promise, resolve } = Promise.withResolvers();
+	request.waitUntil(promise);
+	return Effect.addFinalizer(() => flusher.flush.pipe(Effect.timeoutOption("2 seconds"), Effect.ensuring(Effect.sync(resolve)), Effect.forkDetach));
+}).pipe(Effect.uninterruptible);
+/**
+* When the current scope closes, flushes the OTLP exporters and keeps the
+* Function running until the flush ends, for at most 2 seconds.
+*
+* It registers the wait with Vercel right away, so run it while the request
+* is current. Run it first in the scope: finalizers added later, such as
+* ending a span, run before the flush. Off Vercel, or outside a request, it
+* does nothing, and the exporters' interval sends the telemetry.
+*
+* Use `flushAfterRequest` for an `HttpRouter` app. Use this one when the
+* request has another entry point, with a scope that closes when it ends.
+*/
+const flushOnClose = Effect.flatMap(OtlpExporter.Flusher, flushOnCloseWith);
+/**
+* Global `HttpRouter` middleware that runs `flushOnClose` in each request's
+* scope. That scope closes after the response body is sent, so telemetry
+* recorded while a body streams is in the flush.
+*/
+const flushAfterRequest = HttpRouter.middleware(Effect.map(OtlpExporter.Flusher, (flusher) => (httpEffect) => Effect.andThen(flushOnCloseWith(flusher), httpEffect)), { global: true });
+//#endregion
+export { flushAfterRequest, flushOnClose };
+
+//# sourceMappingURL=Otlp.js.map

package/dist/Otlp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Otlp.js","names":[],"sources":["../src/Otlp.ts"],"sourcesContent":["/**\n * Keeps a Vercel Function running until its OTLP telemetry is exported.\n *\n * Effect's OTLP exporters buffer spans, logs and metrics and export them on\n * an interval. Vercel can suspend the instance once the response is sent, so\n * the interval may never fire and the telemetry is lost. These flush the\n * exporters when a request ends and keep the Function running until the\n * flush is done.\n *\n * @example\n * ```ts\n * import * as VercelOtlp from \"effect-vercel/Otlp\"\n * import { Layer } from \"effect\"\n * import { FetchHttpClient, HttpRouter } from \"effect/http\"\n * import { Otlp } from \"effect/observability\"\n *\n * const { handler } = HttpRouter.toWebHandler(\n *   Layer.merge(Routes, VercelOtlp.flushAfterRequest).pipe(\n *     Layer.provideMerge(Otlp.layerJson({ baseUrl, resource })),\n *     Layer.provide(FetchHttpClient.layer),\n *   ),\n * )\n * ```\n */\n\nimport { Effect, type Layer, type Scope } from \"effect\"\nimport { HttpRouter } from \"effect/http\"\nimport { OtlpExporter } from \"effect/observability\"\nimport { currentRequest } from \"./internal/requestContext.js\"\n\nconst flushOnCloseWith = (flusher: OtlpExporter.Flusher[\"Service\"]) =>\n  Effect.suspend(() => {\n    const request = currentRequest()\n    if (request?.waitUntil === undefined) return Effect.void\n    const { promise, resolve } = Promise.withResolvers<void>()\n    request.waitUntil(promise)\n    // Forked, so a streamed body ends without waiting for the export.\n    return Effect.addFinalizer(() =>\n      flusher.flush.pipe(\n        Effect.timeoutOption(\"2 seconds\"),\n        Effect.ensuring(Effect.sync(resolve)),\n        Effect.forkDetach,\n      ),\n    )\n  }).pipe(\n    // An interrupt before the finalizer is added would leave the wait open.\n    Effect.uninterruptible,\n  )\n\n/**\n * When the current scope closes, flushes the OTLP exporters and keeps the\n * Function running until the flush ends, for at most 2 seconds.\n *\n * It registers the wait with Vercel right away, so run it while the request\n * is current. Run it first in the scope: finalizers added later, such as\n * ending a span, run before the flush. Off Vercel, or outside a request, it\n * does nothing, and the exporters' interval sends the telemetry.\n *\n * Use `flushAfterRequest` for an `HttpRouter` app. Use this one when the\n * request has another entry point, with a scope that closes when it ends.\n */\nexport const flushOnClose: Effect.Effect<void, never, OtlpExporter.Flusher | Scope.Scope> =\n  Effect.flatMap(OtlpExporter.Flusher, flushOnCloseWith)\n\n/**\n * Global `HttpRouter` middleware that runs `flushOnClose` in each request's\n * scope. That scope closes after the response body is sent, so telemetry\n * recorded while a body streams is in the flush.\n */\nexport const flushAfterRequest: Layer.Layer<\n  never,\n  never,\n  HttpRouter.HttpRouter | OtlpExporter.Flusher\n> = HttpRouter.middleware(\n  Effect.map(\n    OtlpExporter.Flusher,\n    (flusher) => (httpEffect) => Effect.andThen(flushOnCloseWith(flusher), httpEffect),\n  ),\n  { global: true },\n)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAM,oBAAoB,YACxB,OAAO,cAAc;CACnB,MAAM,UAAU,eAAe;CAC/B,IAAI,SAAS,cAAc,KAAA,GAAW,OAAO,OAAO;CACpD,MAAM,EAAE,SAAS,YAAY,QAAQ,cAAoB;CACzD,QAAQ,UAAU,OAAO;CAEzB,OAAO,OAAO,mBACZ,QAAQ,MAAM,KACZ,OAAO,cAAc,WAAW,GAChC,OAAO,SAAS,OAAO,KAAK,OAAO,CAAC,GACpC,OAAO,UACT,CACF;AACF,CAAC,CAAC,CAAC,KAED,OAAO,eACT;;;;;;;;;;;;;AAcF,MAAa,eACX,OAAO,QAAQ,aAAa,SAAS,gBAAgB;;;;;;AAOvD,MAAa,oBAIT,WAAW,WACb,OAAO,IACL,aAAa,UACZ,aAAa,eAAe,OAAO,QAAQ,iBAAiB,OAAO,GAAG,UAAU,CACnF,GACA,EAAE,QAAQ,KAAK,CACjB"}

package/dist/PgClient.d.ts

@@ -0,0 +1,17 @@
+import { Layer } from "effect";
+import { PgClient } from "@effect/sql-pg";
+//#region src/PgClient.d.ts
+/** `PgClient.PgPoolConfig` without `stream`, which this module sets. */
+export type Config<R = never> = Omit<PgClient.PgPoolConfig<R>, "stream">;
+/**
+ * `PgClient.layer` from `@effect/sql-pg` that keeps the Function instance up
+ * until the pool has closed every connection, or the request's deadline
+ * comes. Off Vercel it behaves like the plain layer.
+ *
+ * It opens each socket itself, through the `stream` option, and moves the
+ * wait to the request that takes each connection, through `onAcquire`. An
+ * `onAcquire` in `config` still runs, after that.
+ */
+export declare const layer: <R = never>(config: Config<R>) => Layer.Layer<PgClient.PgClient | import("effect/sql/SqlClient").SqlClient, import("effect/sql/SqlError").SqlError, Exclude<R, import("effect/Scope").Scope | import("effect/reactivity/Reactivity").Reactivity>>;
+//#endregion
+//# sourceMappingURL=PgClient.d.ts.map

package/dist/PgClient.js

@@ -0,0 +1,111 @@
+import { t as currentRequest } from "./requestContext-CEUKYTim.js";
+import { Duration, Effect, Layer, Redacted } from "effect";
+import * as Net from "node:net";
+import { PgClient } from "@effect/sql-pg";
+import { constVoid } from "effect/Function";
+//#region src/PgClient.ts
+/**
+* `@effect/sql-pg` for Vercel Functions: a pool that keeps the instance up
+* while it has a connection open.
+*
+* Vercel freezes an instance once no request or `waitUntil` promise is left.
+* A frozen instance keeps its sockets, so a pooler like PgBouncer keeps
+* counting them as clients until the instance wakes up or dies. With many
+* instances, as during a deploy, they fill up `max_client_conn`.
+* `attachDatabasePool` from `@vercel/functions` waits out the idle timeout
+* after each release, but it only supports node-postgres-like pools, and the
+* Effect pool closes idle connections up to twice its `idleTimeout` after
+* their last use. So this layer counts the pool's sockets and waits until
+* the last one closes.
+*
+* @example
+* ```ts
+* import * as PgClient from "effect-vercel/PgClient"
+* import { Redacted } from "effect"
+*
+* const SqlLive = PgClient.layer({
+*   url: Redacted.make(process.env.DATABASE_URL!),
+*   idleTimeout: "5 seconds",
+* })
+* ```
+*/
+/**
+* Keeps the instance up while a tracked socket is open. One `waitUntil`
+* promise holds it, and `follow` moves it to the request running now, as
+* `attachDatabasePool` does, so a busy instance never holds a finished
+* request open. The wait also ends a second before the request's deadline.
+* Outside a request, `follow` keeps the wait where it is.
+*/
+const makeKeepAlive = () => {
+	let open = 0;
+	let release = constVoid;
+	const follow = () => {
+		const request = currentRequest();
+		if (open === 0 || request?.waitUntil === void 0) return;
+		release();
+		const cutoff = Date.parse(request.deadline ?? "") - 1e3;
+		request.waitUntil(new Promise((resolve) => {
+			const timer = Number.isNaN(cutoff) ? void 0 : setTimeout(resolve, cutoff - Date.now());
+			release = () => {
+				clearTimeout(timer);
+				resolve();
+			};
+		}));
+	};
+	const track = (socket) => {
+		open++;
+		follow();
+		socket.once("close", () => {
+			if (--open === 0) release();
+		});
+		return socket;
+	};
+	return {
+		follow,
+		track
+	};
+};
+/**
+* Opens the TCP or Unix socket `@effect/sql-pg` would open for `config`.
+* It still runs TLS and the startup on it.
+*/
+const connect = (config) => {
+	const url = config.url && new URL(Redacted.value(config.url));
+	const param = (name) => url?.searchParams.getAll(name).at(-1);
+	const urlHost = url?.hostname && decodeURIComponent(url.hostname.replace(/^\[(.*)\]$/, "$1"));
+	const host = config.host ?? param("host") ?? (urlHost || "localhost");
+	const port = config.port ?? Number(param("port") ?? (url?.port || 5432));
+	const path = config.path ?? (host.startsWith("/") ? `${host}/.s.PGSQL.${port}` : void 0);
+	if (path !== void 0) return Net.connect({ path });
+	return Net.connect({
+		host,
+		port,
+		noDelay: true,
+		...config.keepAlive !== void 0 && {
+			keepAlive: true,
+			keepAliveInitialDelay: Duration.toMillis(Duration.fromInputUnsafe(config.keepAlive))
+		}
+	});
+};
+/**
+* `PgClient.layer` from `@effect/sql-pg` that keeps the Function instance up
+* until the pool has closed every connection, or the request's deadline
+* comes. Off Vercel it behaves like the plain layer.
+*
+* It opens each socket itself, through the `stream` option, and moves the
+* wait to the request that takes each connection, through `onAcquire`. An
+* `onAcquire` in `config` still runs, after that.
+*/
+const layer = (config) => Layer.suspend(() => {
+	const keepAlive = makeKeepAlive();
+	const follow = Effect.sync(keepAlive.follow);
+	return PgClient.layer({
+		...config,
+		stream: () => keepAlive.track(connect(config)),
+		onAcquire: config.onAcquire ? Effect.andThen(follow, config.onAcquire) : follow
+	});
+});
+//#endregion
+export { layer };
+
+//# sourceMappingURL=PgClient.js.map

package/dist/PgClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PgClient.js","names":[],"sources":["../src/PgClient.ts"],"sourcesContent":["/**\n * `@effect/sql-pg` for Vercel Functions: a pool that keeps the instance up\n * while it has a connection open.\n *\n * Vercel freezes an instance once no request or `waitUntil` promise is left.\n * A frozen instance keeps its sockets, so a pooler like PgBouncer keeps\n * counting them as clients until the instance wakes up or dies. With many\n * instances, as during a deploy, they fill up `max_client_conn`.\n * `attachDatabasePool` from `@vercel/functions` waits out the idle timeout\n * after each release, but it only supports node-postgres-like pools, and the\n * Effect pool closes idle connections up to twice its `idleTimeout` after\n * their last use. So this layer counts the pool's sockets and waits until\n * the last one closes.\n *\n * @example\n * ```ts\n * import * as PgClient from \"effect-vercel/PgClient\"\n * import { Redacted } from \"effect\"\n *\n * const SqlLive = PgClient.layer({\n *   url: Redacted.make(process.env.DATABASE_URL!),\n *   idleTimeout: \"5 seconds\",\n * })\n * ```\n */\n\nimport * as Net from \"node:net\"\nimport { PgClient } from \"@effect/sql-pg\"\nimport { Duration, Effect, Layer, Redacted } from \"effect\"\nimport { constVoid } from \"effect/Function\"\nimport { currentRequest } from \"./internal/requestContext.js\"\n\n/**\n * Keeps the instance up while a tracked socket is open. One `waitUntil`\n * promise holds it, and `follow` moves it to the request running now, as\n * `attachDatabasePool` does, so a busy instance never holds a finished\n * request open. The wait also ends a second before the request's deadline.\n * Outside a request, `follow` keeps the wait where it is.\n */\nconst makeKeepAlive = () => {\n  let open = 0\n  let release = constVoid\n\n  const follow = () => {\n    const request = currentRequest()\n    if (open === 0 || request?.waitUntil === undefined) return\n    release()\n    const cutoff = Date.parse(request.deadline ?? \"\") - 1_000\n    request.waitUntil(\n      new Promise<void>((resolve) => {\n        const timer = Number.isNaN(cutoff) ? undefined : setTimeout(resolve, cutoff - Date.now())\n        release = () => {\n          clearTimeout(timer)\n          resolve()\n        }\n      }),\n    )\n  }\n\n  const track = (socket: Net.Socket) => {\n    open++\n    follow()\n    socket.once(\"close\", () => {\n      if (--open === 0) release()\n    })\n    return socket\n  }\n\n  return { follow, track }\n}\n\n/** `PgClient.PgPoolConfig` without `stream`, which this module sets. */\nexport type Config<R = never> = Omit<PgClient.PgPoolConfig<R>, \"stream\">\n\n/**\n * Opens the TCP or Unix socket `@effect/sql-pg` would open for `config`.\n * It still runs TLS and the startup on it.\n */\nconst connect = (config: Config<unknown>): Net.Socket => {\n  const url = config.url && new URL(Redacted.value(config.url))\n  const param = (name: string) => url?.searchParams.getAll(name).at(-1)\n  const urlHost = url?.hostname && decodeURIComponent(url.hostname.replace(/^\\[(.*)\\]$/, \"$1\"))\n  const host = config.host ?? param(\"host\") ?? (urlHost || \"localhost\")\n  const port = config.port ?? Number(param(\"port\") ?? (url?.port || 5432))\n  const path = config.path ?? (host.startsWith(\"/\") ? `${host}/.s.PGSQL.${port}` : undefined)\n  if (path !== undefined) return Net.connect({ path })\n  return Net.connect({\n    host,\n    port,\n    noDelay: true,\n    ...(config.keepAlive !== undefined && {\n      keepAlive: true,\n      keepAliveInitialDelay: Duration.toMillis(Duration.fromInputUnsafe(config.keepAlive)),\n    }),\n  })\n}\n\n/**\n * `PgClient.layer` from `@effect/sql-pg` that keeps the Function instance up\n * until the pool has closed every connection, or the request's deadline\n * comes. Off Vercel it behaves like the plain layer.\n *\n * It opens each socket itself, through the `stream` option, and moves the\n * wait to the request that takes each connection, through `onAcquire`. An\n * `onAcquire` in `config` still runs, after that.\n */\nexport const layer = <R = never>(config: Config<R>) =>\n  Layer.suspend(() => {\n    const keepAlive = makeKeepAlive()\n    const follow = Effect.sync(keepAlive.follow)\n    return PgClient.layer({\n      ...config,\n      stream: () => keepAlive.track(connect(config)),\n      onAcquire: config.onAcquire ? Effect.andThen(follow, config.onAcquire) : follow,\n    })\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAM,sBAAsB;CAC1B,IAAI,OAAO;CACX,IAAI,UAAU;CAEd,MAAM,eAAe;EACnB,MAAM,UAAU,eAAe;EAC/B,IAAI,SAAS,KAAK,SAAS,cAAc,KAAA,GAAW;EACpD,QAAQ;EACR,MAAM,SAAS,KAAK,MAAM,QAAQ,YAAY,EAAE,IAAI;EACpD,QAAQ,UACN,IAAI,SAAe,YAAY;GAC7B,MAAM,QAAQ,OAAO,MAAM,MAAM,IAAI,KAAA,IAAY,WAAW,SAAS,SAAS,KAAK,IAAI,CAAC;GACxF,gBAAgB;IACd,aAAa,KAAK;IAClB,QAAQ;GACV;EACF,CAAC,CACH;CACF;CAEA,MAAM,SAAS,WAAuB;EACpC;EACA,OAAO;EACP,OAAO,KAAK,eAAe;GACzB,IAAI,EAAE,SAAS,GAAG,QAAQ;EAC5B,CAAC;EACD,OAAO;CACT;CAEA,OAAO;EAAE;EAAQ;CAAM;AACzB;;;;;AASA,MAAM,WAAW,WAAwC;CACvD,MAAM,MAAM,OAAO,OAAO,IAAI,IAAI,SAAS,MAAM,OAAO,GAAG,CAAC;CAC5D,MAAM,SAAS,SAAiB,KAAK,aAAa,OAAO,IAAI,CAAC,CAAC,GAAG,EAAE;CACpE,MAAM,UAAU,KAAK,YAAY,mBAAmB,IAAI,SAAS,QAAQ,cAAc,IAAI,CAAC;CAC5F,MAAM,OAAO,OAAO,QAAQ,MAAM,MAAM,MAAM,WAAW;CACzD,MAAM,OAAO,OAAO,QAAQ,OAAO,MAAM,MAAM,MAAM,KAAK,QAAQ,KAAK;CACvE,MAAM,OAAO,OAAO,SAAS,KAAK,WAAW,GAAG,IAAI,GAAG,KAAK,YAAY,SAAS,KAAA;CACjF,IAAI,SAAS,KAAA,GAAW,OAAO,IAAI,QAAQ,EAAE,KAAK,CAAC;CACnD,OAAO,IAAI,QAAQ;EACjB;EACA;EACA,SAAS;EACT,GAAI,OAAO,cAAc,KAAA,KAAa;GACpC,WAAW;GACX,uBAAuB,SAAS,SAAS,SAAS,gBAAgB,OAAO,SAAS,CAAC;EACrF;CACF,CAAC;AACH;;;;;;;;;;AAWA,MAAa,SAAoB,WAC/B,MAAM,cAAc;CAClB,MAAM,YAAY,cAAc;CAChC,MAAM,SAAS,OAAO,KAAK,UAAU,MAAM;CAC3C,OAAO,SAAS,MAAM;EACpB,GAAG;EACH,cAAc,UAAU,MAAM,QAAQ,MAAM,CAAC;EAC7C,WAAW,OAAO,YAAY,OAAO,QAAQ,QAAQ,OAAO,SAAS,IAAI;CAC3E,CAAC;AACH,CAAC"}

package/dist/requestContext-CEUKYTim.js

@@ -0,0 +1,14 @@
+//#region src/internal/requestContext.ts
+/**
+* Vercel exposes the current request's context on a well-known global symbol.
+* `@vercel/functions` reads `waitUntil` and the deadline from there. Off
+* Vercel, or outside a request, there is no `waitUntil`.
+*/
+const REQUEST_CONTEXT = Symbol.for("@vercel/request-context");
+const currentRequest = () => {
+	return globalThis[REQUEST_CONTEXT]?.get?.();
+};
+//#endregion
+export { currentRequest as t };
+
+//# sourceMappingURL=requestContext-CEUKYTim.js.map

package/dist/requestContext-CEUKYTim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestContext-CEUKYTim.js","names":["holder"],"sources":["../src/internal/requestContext.ts"],"sourcesContent":["/**\n * Vercel exposes the current request's context on a well-known global symbol.\n * `@vercel/functions` reads `waitUntil` and the deadline from there. Off\n * Vercel, or outside a request, there is no `waitUntil`.\n */\nconst REQUEST_CONTEXT = Symbol.for(\"@vercel/request-context\")\n\ntype RequestContext = {\n  readonly waitUntil?: (promise: Promise<unknown>) => void\n  readonly deadline?: string\n}\n\nexport const currentRequest = (): RequestContext | undefined => {\n  const holder = globalThis as typeof globalThis & {\n    [REQUEST_CONTEXT]?: { get?: () => RequestContext | undefined }\n  }\n  return holder[REQUEST_CONTEXT]?.get?.()\n}\n"],"mappings":";;;;;;AAKA,MAAM,kBAAkB,OAAO,IAAI,yBAAyB;AAO5D,MAAa,uBAAmD;CAI9D,OAAOA,WAAO,gBAAgB,EAAE,MAAM;AACxC"}

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "effect-vercel",
-  "version": "0.5.0",
-  "description": "Effect integrations for Vercel: AI Gateway, OIDC, Runtime Cache, waitUntil",
+  "version": "0.7.0",
+  "description": "Effect integrations for Vercel: AI Gateway, OIDC, OTLP flushing, Postgres pools, Runtime Cache, waitUntil",
   "keywords": [
     "ai-gateway",
     "effect",
     "effect-ai",
     "oidc",
+    "opentelemetry",
+    "otlp",
+    "postgres",
     "runtime-cache",
     "vercel",
     "wait-until"
@@ -32,6 +35,8 @@
     "./AiGatewayCredentials": "./dist/AiGatewayCredentials.js",
     "./Functions": "./dist/Functions.js",
     "./Oidc": "./dist/Oidc.js",
+    "./Otlp": "./dist/Otlp.js",
+    "./PgClient": "./dist/PgClient.js",
     "./RuntimeCache": "./dist/RuntimeCache.js",
     "./package.json": "./package.json"
   },
@@ -48,12 +53,13 @@
     "prepublishOnly": "pnpm check && pnpm test && pnpm build"
   },
   "devDependencies": {
-    "@effect/ai-anthropic": "^4.0.0",
+    "@effect/ai-anthropic": "^4.1.0",
     "@effect/language-service": "^0.87.3",
-    "@effect/vitest": "^4.0.0",
+    "@effect/sql-pg": "^4.1.0",
+    "@effect/vitest": "^4.1.0",
     "@types/node": "^24",
     "@vercel/functions": "^3.9.9",
-    "effect": "^4.0.0",
+    "effect": "^4.1.0",
     "oxfmt": "^0.68.0",
     "oxlint": "^1.83.0",
     "tsdown": "^0.23.0",
@@ -62,13 +68,17 @@
   },
   "peerDependencies": {
     "@effect/ai-anthropic": "^4.0.0",
+    "@effect/sql-pg": "^4.0.6",
     "@vercel/functions": "^3.9.9",
-    "effect": "^4.0.0"
+    "effect": "^4.1.0"
   },
   "peerDependenciesMeta": {
     "@effect/ai-anthropic": {
       "optional": true
     },
+    "@effect/sql-pg": {
+      "optional": true
+    },
     "@vercel/functions": {
       "optional": true
     }

package/src/Otlp.ts

@@ -0,0 +1,80 @@
+/**
+ * Keeps a Vercel Function running until its OTLP telemetry is exported.
+ *
+ * Effect's OTLP exporters buffer spans, logs and metrics and export them on
+ * an interval. Vercel can suspend the instance once the response is sent, so
+ * the interval may never fire and the telemetry is lost. These flush the
+ * exporters when a request ends and keep the Function running until the
+ * flush is done.
+ *
+ * @example
+ * ```ts
+ * import * as VercelOtlp from "effect-vercel/Otlp"
+ * import { Layer } from "effect"
+ * import { FetchHttpClient, HttpRouter } from "effect/http"
+ * import { Otlp } from "effect/observability"
+ *
+ * const { handler } = HttpRouter.toWebHandler(
+ *   Layer.merge(Routes, VercelOtlp.flushAfterRequest).pipe(
+ *     Layer.provideMerge(Otlp.layerJson({ baseUrl, resource })),
+ *     Layer.provide(FetchHttpClient.layer),
+ *   ),
+ * )
+ * ```
+ */
+
+import { Effect, type Layer, type Scope } from "effect"
+import { HttpRouter } from "effect/http"
+import { OtlpExporter } from "effect/observability"
+import { currentRequest } from "./internal/requestContext.js"
+
+const flushOnCloseWith = (flusher: OtlpExporter.Flusher["Service"]) =>
+  Effect.suspend(() => {
+    const request = currentRequest()
+    if (request?.waitUntil === undefined) return Effect.void
+    const { promise, resolve } = Promise.withResolvers<void>()
+    request.waitUntil(promise)
+    // Forked, so a streamed body ends without waiting for the export.
+    return Effect.addFinalizer(() =>
+      flusher.flush.pipe(
+        Effect.timeoutOption("2 seconds"),
+        Effect.ensuring(Effect.sync(resolve)),
+        Effect.forkDetach,
+      ),
+    )
+  }).pipe(
+    // An interrupt before the finalizer is added would leave the wait open.
+    Effect.uninterruptible,
+  )
+
+/**
+ * When the current scope closes, flushes the OTLP exporters and keeps the
+ * Function running until the flush ends, for at most 2 seconds.
+ *
+ * It registers the wait with Vercel right away, so run it while the request
+ * is current. Run it first in the scope: finalizers added later, such as
+ * ending a span, run before the flush. Off Vercel, or outside a request, it
+ * does nothing, and the exporters' interval sends the telemetry.
+ *
+ * Use `flushAfterRequest` for an `HttpRouter` app. Use this one when the
+ * request has another entry point, with a scope that closes when it ends.
+ */
+export const flushOnClose: Effect.Effect<void, never, OtlpExporter.Flusher | Scope.Scope> =
+  Effect.flatMap(OtlpExporter.Flusher, flushOnCloseWith)
+
+/**
+ * Global `HttpRouter` middleware that runs `flushOnClose` in each request's
+ * scope. That scope closes after the response body is sent, so telemetry
+ * recorded while a body streams is in the flush.
+ */
+export const flushAfterRequest: Layer.Layer<
+  never,
+  never,
+  HttpRouter.HttpRouter | OtlpExporter.Flusher
+> = HttpRouter.middleware(
+  Effect.map(
+    OtlpExporter.Flusher,
+    (flusher) => (httpEffect) => Effect.andThen(flushOnCloseWith(flusher), httpEffect),
+  ),
+  { global: true },
+)

package/src/PgClient.ts

@@ -0,0 +1,116 @@
+/**
+ * `@effect/sql-pg` for Vercel Functions: a pool that keeps the instance up
+ * while it has a connection open.
+ *
+ * Vercel freezes an instance once no request or `waitUntil` promise is left.
+ * A frozen instance keeps its sockets, so a pooler like PgBouncer keeps
+ * counting them as clients until the instance wakes up or dies. With many
+ * instances, as during a deploy, they fill up `max_client_conn`.
+ * `attachDatabasePool` from `@vercel/functions` waits out the idle timeout
+ * after each release, but it only supports node-postgres-like pools, and the
+ * Effect pool closes idle connections up to twice its `idleTimeout` after
+ * their last use. So this layer counts the pool's sockets and waits until
+ * the last one closes.
+ *
+ * @example
+ * ```ts
+ * import * as PgClient from "effect-vercel/PgClient"
+ * import { Redacted } from "effect"
+ *
+ * const SqlLive = PgClient.layer({
+ *   url: Redacted.make(process.env.DATABASE_URL!),
+ *   idleTimeout: "5 seconds",
+ * })
+ * ```
+ */
+
+import * as Net from "node:net"
+import { PgClient } from "@effect/sql-pg"
+import { Duration, Effect, Layer, Redacted } from "effect"
+import { constVoid } from "effect/Function"
+import { currentRequest } from "./internal/requestContext.js"
+
+/**
+ * Keeps the instance up while a tracked socket is open. One `waitUntil`
+ * promise holds it, and `follow` moves it to the request running now, as
+ * `attachDatabasePool` does, so a busy instance never holds a finished
+ * request open. The wait also ends a second before the request's deadline.
+ * Outside a request, `follow` keeps the wait where it is.
+ */
+const makeKeepAlive = () => {
+  let open = 0
+  let release = constVoid
+
+  const follow = () => {
+    const request = currentRequest()
+    if (open === 0 || request?.waitUntil === undefined) return
+    release()
+    const cutoff = Date.parse(request.deadline ?? "") - 1_000
+    request.waitUntil(
+      new Promise<void>((resolve) => {
+        const timer = Number.isNaN(cutoff) ? undefined : setTimeout(resolve, cutoff - Date.now())
+        release = () => {
+          clearTimeout(timer)
+          resolve()
+        }
+      }),
+    )
+  }
+
+  const track = (socket: Net.Socket) => {
+    open++
+    follow()
+    socket.once("close", () => {
+      if (--open === 0) release()
+    })
+    return socket
+  }
+
+  return { follow, track }
+}
+
+/** `PgClient.PgPoolConfig` without `stream`, which this module sets. */
+export type Config<R = never> = Omit<PgClient.PgPoolConfig<R>, "stream">
+
+/**
+ * Opens the TCP or Unix socket `@effect/sql-pg` would open for `config`.
+ * It still runs TLS and the startup on it.
+ */
+const connect = (config: Config<unknown>): Net.Socket => {
+  const url = config.url && new URL(Redacted.value(config.url))
+  const param = (name: string) => url?.searchParams.getAll(name).at(-1)
+  const urlHost = url?.hostname && decodeURIComponent(url.hostname.replace(/^\[(.*)\]$/, "$1"))
+  const host = config.host ?? param("host") ?? (urlHost || "localhost")
+  const port = config.port ?? Number(param("port") ?? (url?.port || 5432))
+  const path = config.path ?? (host.startsWith("/") ? `${host}/.s.PGSQL.${port}` : undefined)
+  if (path !== undefined) return Net.connect({ path })
+  return Net.connect({
+    host,
+    port,
+    noDelay: true,
+    ...(config.keepAlive !== undefined && {
+      keepAlive: true,
+      keepAliveInitialDelay: Duration.toMillis(Duration.fromInputUnsafe(config.keepAlive)),
+    }),
+  })
+}
+
+/**
+ * `PgClient.layer` from `@effect/sql-pg` that keeps the Function instance up
+ * until the pool has closed every connection, or the request's deadline
+ * comes. Off Vercel it behaves like the plain layer.
+ *
+ * It opens each socket itself, through the `stream` option, and moves the
+ * wait to the request that takes each connection, through `onAcquire`. An
+ * `onAcquire` in `config` still runs, after that.
+ */
+export const layer = <R = never>(config: Config<R>) =>
+  Layer.suspend(() => {
+    const keepAlive = makeKeepAlive()
+    const follow = Effect.sync(keepAlive.follow)
+    return PgClient.layer({
+      ...config,
+      stream: () => keepAlive.track(connect(config)),
+      onAcquire: config.onAcquire ? Effect.andThen(follow, config.onAcquire) : follow,
+    })
+  })

package/src/internal/requestContext.ts

@@ -0,0 +1,18 @@
+/**
+ * Vercel exposes the current request's context on a well-known global symbol.
+ * `@vercel/functions` reads `waitUntil` and the deadline from there. Off
+ * Vercel, or outside a request, there is no `waitUntil`.
+ */
+const REQUEST_CONTEXT = Symbol.for("@vercel/request-context")
+
+type RequestContext = {
+  readonly waitUntil?: (promise: Promise<unknown>) => void
+  readonly deadline?: string
+}
+
+export const currentRequest = (): RequestContext | undefined => {
+  const holder = globalThis as typeof globalThis & {
+    [REQUEST_CONTEXT]?: { get?: () => RequestContext | undefined }
+  }
+  return holder[REQUEST_CONTEXT]?.get?.()
+}