effect-vercel 0.6.0 → 0.7.0

package/README.md

@@ -13,6 +13,7 @@ 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` |
 
@@ -146,6 +147,58 @@ 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

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.js

@@ -1,3 +1,4 @@
+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";
@@ -29,15 +30,6 @@ import { constVoid } from "effect/Function";
 * ```
 */
 /**
-* 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?.();
-};
-/**
 * 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

package/dist/PgClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"PgClient.js","names":["holder"],"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\"\n\n/**\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\nconst 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\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,MAAM,kBAAkB,OAAO,IAAI,yBAAyB;AAO5D,MAAM,uBAAmD;CAIvD,OAAOA,WAAO,gBAAgB,EAAE,MAAM;AACxC;;;;;;;;AASA,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"}
+{"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,14 @@
 {
   "name": "effect-vercel",
-  "version": "0.6.0",
-  "description": "Effect integrations for Vercel: AI Gateway, OIDC, Postgres pools, 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",
@@ -33,6 +35,7 @@
     "./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"
@@ -50,13 +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/sql-pg": "^4.0.6",
-    "@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.6",
+    "effect": "^4.1.0",
     "oxfmt": "^0.68.0",
     "oxlint": "^1.83.0",
     "tsdown": "^0.23.0",
@@ -67,7 +70,7 @@
     "@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": {

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

@@ -28,25 +28,7 @@ import * as Net from "node:net"
 import { PgClient } from "@effect/sql-pg"
 import { Duration, Effect, Layer, Redacted } from "effect"
 import { constVoid } from "effect/Function"
-
-/**
- * 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
-}
-
-const currentRequest = (): RequestContext | undefined => {
-  const holder = globalThis as typeof globalThis & {
-    [REQUEST_CONTEXT]?: { get?: () => RequestContext | undefined }
-  }
-  return holder[REQUEST_CONTEXT]?.get?.()
-}
+import { currentRequest } from "./internal/requestContext.js"
 
 /**
  * Keeps the instance up while a tracked socket is open. One `waitUntil`

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?.()
+}