effect-cf 0.25.1 → 0.25.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # effect-cf
 
+## 0.25.3
+
+### Patch Changes
+
+- [#92](https://github.com/danieljvdm/effect-cf/pull/92) [`f174800`](https://github.com/danieljvdm/effect-cf/commit/f1748004e463d4e54c22e7c77fdea68ff8de7f82) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Flush configured OTLP telemetry after Durable Object alarm handlers, including failed alarms, so buffered telemetry is exported consistently with fetch and native RPC handlers.
+
+## 0.25.2
+
+### Patch Changes
+
+- [#90](https://github.com/danieljvdm/effect-cf/pull/90) [`56c1b2d`](https://github.com/danieljvdm/effect-cf/commit/56c1b2dfa30cbcc2336f28a8d8f7a48032f565df) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Flush configured OTLP telemetry after native Worker and Durable Object RPC handlers complete. Flush and scheduling failures keep the handler outcome unchanged and emit only bounded framework diagnostics.
+
 ## 0.25.1
 
 ### Patch Changes

package/dist/Vitest.d.mts

@@ -1,5 +1,5 @@
 import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-COCtoJXa.mjs";
-import { c as DurableObjectState, l as DurableObjectStateService, o as WorkflowInstanceStatusName } from "./WorkflowBinding-Bzs5kmoE.mjs";
+import { c as DurableObjectState, l as DurableObjectStateService, o as WorkflowInstanceStatusName } from "./WorkflowBinding-D5iWzCUa.mjs";
 import { Effect, Layer } from "effect";
 import { DurableObject } from "cloudflare:workers";
 import { adminSecretsStore as adminSecretsStore$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1 } from "cloudflare:test";

package/dist/{WorkflowBinding-Bzs5kmoE.d.mts → WorkflowBinding-D5iWzCUa.d.mts}

@@ -881,7 +881,12 @@ interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc e
   readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<RRuntime | REvent>>;
   /** Queue consumer handler invoked per message batch. */
   readonly queue?: QueueHandler<RRuntime | REvent>;
-  /** Optional RPC methods exposed as class instance methods. */
+  /**
+   * Optional RPC methods exposed as class instance methods.
+   *
+   * After every invocation, the configured OTLP flusher is scheduled through
+   * `WorkerContext.waitUntil`, including when the handler fails.
+   */
   readonly rpc?: Rpc;
 }
 type FetchWorkerOptions<RRuntime, REvent = never, EventLayerError = never> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Record<never, never>>, "rpc"> & {

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { a as Environment_d_exports, c as WorkerEnvironment, i as Binding_d_exports, n as BindingService, o as WorkerConfig, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-COCtoJXa.mjs";
 import { t as Hyperdrive_d_exports } from "./Hyperdrive-6p59yyVk.mjs";
-import { A as Rpc_d_exports, C as QueueBinding_d_exports, D as RpcDefinition_d_exports, E as ReservedMethodName$2, M as DurableWebSocket, N as DurableObjectStorage_d_exports, O as ServiceFreeSchema$1, P as StorageOperationError, S as QueueDefinition_d_exports, T as Method$2, _ as AsyncMethodArgs, a as WorkflowInstanceCreateOptions, b as AsyncMethodSuccess, c as DurableObjectState, d as ExecutionContext, f as NativeRequest, g as ServiceBinding_d_exports, h as WorkerDefinition_d_exports, i as WorkflowInstanceCreateBatchOptions, j as DurableObjectWebSocket_d_exports, k as Provider, m as Worker_d_exports, n as WorkflowBinding_d_exports, p as WorkerContext, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient, u as DurableObjectState_d_exports, v as AsyncMethodCloudflareReturn, w as Definition$4, x as Queue_d_exports, y as AsyncMethodKey } from "./WorkflowBinding-Bzs5kmoE.mjs";
+import { A as Rpc_d_exports, C as QueueBinding_d_exports, D as RpcDefinition_d_exports, E as ReservedMethodName$2, M as DurableWebSocket, N as DurableObjectStorage_d_exports, O as ServiceFreeSchema$1, P as StorageOperationError, S as QueueDefinition_d_exports, T as Method$2, _ as AsyncMethodArgs, a as WorkflowInstanceCreateOptions, b as AsyncMethodSuccess, c as DurableObjectState, d as ExecutionContext, f as NativeRequest, g as ServiceBinding_d_exports, h as WorkerDefinition_d_exports, i as WorkflowInstanceCreateBatchOptions, j as DurableObjectWebSocket_d_exports, k as Provider, m as Worker_d_exports, n as WorkflowBinding_d_exports, p as WorkerContext, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient, u as DurableObjectState_d_exports, v as AsyncMethodCloudflareReturn, w as Definition$4, x as Queue_d_exports, y as AsyncMethodKey } from "./WorkflowBinding-D5iWzCUa.mjs";
 import { Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Redacted, Schema, Scope } from "effect";
 import { Headers as Headers$1, HttpClient, HttpClientResponse } from "effect/unstable/http";
 import { OtlpExporter } from "effect/unstable/observability";
@@ -1099,7 +1099,12 @@ interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never
    * Object storage if work must happen only once per id.
    */
   readonly initialize?: Effect.Effect<void, unknown, HandlerContext<RRuntime>>;
-  /** Optional RPC methods exposed as Durable Object instance methods. */
+  /**
+   * Optional RPC methods exposed as Durable Object instance methods.
+   *
+   * After every invocation, the configured OTLP flusher is scheduled through
+   * `DurableObjectState.waitUntil`, including when the handler fails.
+   */
   readonly rpc?: Rpc;
   /** Optional fetch handler for HTTP/WebSocket requests. */
   readonly fetch?: Effect.Effect<Response, unknown, FetchContext<RRuntime | REvent>>;
@@ -1111,6 +1116,12 @@ interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never
    * the Durable Object's single managed runtime boundary.
    */
   readonly alarms?: Effect.Effect<unknown, unknown, HandlerContext<RRuntime | REvent>>;
+  /**
+   * Optional raw alarm handler.
+   *
+   * After every invocation, the configured OTLP flusher is scheduled through
+   * `DurableObjectState.waitUntil`, including when the handler fails.
+   */
   readonly alarm?: (alarmInfo?: globalThis.AlarmInvocationInfo) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
   readonly webSocketMessage?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
   readonly webSocketClose?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;

package/dist/index.mjs

@@ -683,8 +683,13 @@ const layer$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
 *
 * Every layer exposes {@link OtlpExporter.Flusher}, which drains buffered
 * telemetry on demand. Cloudflare isolates can freeze before the periodic
-* export interval fires, so flush explicitly before returning a response, or
-* hand the flush to `ctx.waitUntil`:
+* export interval fires. Effect-backed Worker fetch handlers, Worker or
+* Durable Object native RPC handlers, and Durable Object alarm handlers
+* schedule this flusher automatically.
+* Flush or scheduling failures do not replace the handler outcome and emit
+* only bounded framework diagnostics without attaching the foreign cause.
+* Other entrypoint lifecycles can flush explicitly or hand the flush to their
+* `waitUntil` mechanism:
 *
 * ```ts
 * const flusher = yield* OtlpExporter.Flusher;
@@ -1347,13 +1352,14 @@ const make$11 = (id, methods) => {
 //#endregion
 //#region src/internal/Entrypoint.ts
 const provideEntrypointServices = (layer, services) => layer.pipe(Layer.provideMerge(services));
-const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run) => {
+const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run, onExit) => {
 	const methods = rpc ?? {};
 	assertNoReservedMethods(target, methods, reservedMethodNames);
 	for (const [key, method] of Object.entries(methods)) Object.defineProperty(prototype, key, {
 		enumerable: true,
 		value(...args) {
-			return run(this, Effect.suspend(() => method(...args)).pipe(Effect.mapError(encodeWireError)));
+			const handler = Effect.suspend(() => method(...args)).pipe(Effect.mapError(encodeWireError));
+			return run(this, onExit === void 0 ? handler : handler.pipe(Effect.onExit(() => onExit(this))));
 		}
 	});
 };
@@ -1386,6 +1392,18 @@ const runEventPromise = (runtime, effect, eventLayer) => {
 	return runtime.runPromise(Effect.scoped(withEventLayer));
 };
 //#endregion
+//#region src/internal/Telemetry.ts
+const logFlushFailure = Effect.logError("Telemetry flush failed").pipe(Effect.ignoreCause);
+const logFlushSchedulingFailure = Effect.logError("Telemetry flush scheduling failed").pipe(Effect.ignoreCause);
+/**
+* Schedules a configured OTLP flusher through the current Cloudflare event.
+*/
+const scheduleTelemetryFlush$2 = (waitUntil) => Effect.gen(function* () {
+	const flusher = yield* Effect.serviceOption(OtlpExporter.Flusher);
+	if (Option.isNone(flusher)) return;
+	yield* waitUntil(flusher.value.flush.pipe(Effect.catchCause(() => logFlushFailure)));
+}).pipe(Effect.catchCause(() => logFlushSchedulingFailure));
+//#endregion
 //#region src/Rpc.ts
 var Rpc_exports = /* @__PURE__ */ __exportAll({
 	RpcStub: () => RpcStub,
@@ -1755,10 +1773,7 @@ const isWorkerOptions = (options) => !Effect.isEffect(options);
 * (including streaming bodies still being consumed). It is a no-op when the
 * context does not contain an `OtlpExporter.Flusher`.
 */
-const scheduleTelemetryFlush = Effect.flatMap(Effect.serviceOption(OtlpExporter.Flusher), Option.match({
-	onNone: () => Effect.void,
-	onSome: (flusher) => Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flusher.flush))
-}));
+const scheduleTelemetryFlush$1 = scheduleTelemetryFlush$2((flush) => Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flush)));
 function make$9(layer, optionsOrFetch) {
 	const options = isWorkerOptions(optionsOrFetch) ? optionsOrFetch : { fetch: optionsOrFetch };
 	class EffectWorker extends WorkerEntrypoint {
@@ -1778,7 +1793,7 @@ function make$9(layer, optionsOrFetch) {
 			if (fetchHandler === void 0) return Promise.resolve(new Response("Not Found", { status: 404 }));
 			const ctx = requestContext ?? this.ctx;
 			const requestServices = Layer.mergeAll(Layer.succeed(NativeRequest, request), Layer.succeed(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request)), Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx)));
-			return this[RunSymbol$1](renderFetchSuccess(fetchHandler).pipe(Effect.tap(() => scheduleTelemetryFlush), Effect.provide(requestServices)));
+			return this[RunSymbol$1](renderFetchSuccess(fetchHandler).pipe(Effect.tap(() => scheduleTelemetryFlush$1), Effect.provide(requestServices)));
 		}
 		queue(batch) {
 			const queueHandler = options.queue;
@@ -1787,7 +1802,7 @@ function make$9(layer, optionsOrFetch) {
 			return this[RunSymbol$1](queueHandler(fromMessageBatch(batch, messages)));
 		}
 	}
-	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect) => self[RunSymbol$1](effect));
+	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect) => self[RunSymbol$1](effect), () => scheduleTelemetryFlush$1);
 	return assumeEntrypointClass(EffectWorker);
 }
 /**
@@ -2080,6 +2095,7 @@ const reservedMethodNames = /* @__PURE__ */ new Set([
 	"webSocketError"
 ]);
 const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
+const scheduleTelemetryFlush = scheduleTelemetryFlush$2((flush) => Effect.flatMap(DurableObjectState, (state) => state.waitUntil(flush)));
 /**
 * Creates a Durable Object class backed by a single managed Effect runtime.
 */
@@ -2103,12 +2119,11 @@ const make$7 = (layer, options = {}) => {
 		alarm(alarmInfo) {
 			const logicalAlarms = options.alarms?.pipe(Effect.asVoid);
 			const rawAlarm = options.alarm?.(alarmInfo);
-			if (logicalAlarms !== void 0 && rawAlarm !== void 0) return this[RunSymbol](Effect.gen(function* () {
+			const alarmEffect = logicalAlarms !== void 0 && rawAlarm !== void 0 ? Effect.gen(function* () {
 				yield* logicalAlarms;
 				yield* rawAlarm;
-			}));
-			if (logicalAlarms !== void 0) return this[RunSymbol](logicalAlarms);
-			if (rawAlarm !== void 0) return this[RunSymbol](rawAlarm);
+			}) : logicalAlarms ?? rawAlarm;
+			if (alarmEffect !== void 0) return this[RunSymbol](alarmEffect.pipe(Effect.onExit(() => scheduleTelemetryFlush)));
 		}
 		webSocketMessage(socket, message) {
 			if (options.webSocketMessage !== void 0) return this[RunSymbol](options.webSocketMessage(fromWebSocket(socket), message));
@@ -2120,7 +2135,7 @@ const make$7 = (layer, options = {}) => {
 			if (options.webSocketError !== void 0) return this[RunSymbol](options.webSocketError(fromWebSocket(socket), error));
 		}
 	}
-	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect));
+	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect), () => scheduleTelemetryFlush);
 	return assumeEntrypointClass(EffectDurableObject);
 };
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.25.1",
+  "version": "0.25.3",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

package/src/CloudflareOtlp.ts

@@ -3,8 +3,13 @@
  *
  * Every layer exposes {@link OtlpExporter.Flusher}, which drains buffered
  * telemetry on demand. Cloudflare isolates can freeze before the periodic
- * export interval fires, so flush explicitly before returning a response, or
- * hand the flush to `ctx.waitUntil`:
+ * export interval fires. Effect-backed Worker fetch handlers, Worker or
+ * Durable Object native RPC handlers, and Durable Object alarm handlers
+ * schedule this flusher automatically.
+ * Flush or scheduling failures do not replace the handler outcome and emit
+ * only bounded framework diagnostics without attaching the foreign cause.
+ * Other entrypoint lifecycles can flush explicitly or hand the flush to their
+ * `waitUntil` mechanism:
  *
  * ```ts
  * const flusher = yield* OtlpExporter.Flusher;

package/src/DurableObject.ts

@@ -7,6 +7,7 @@ import { DurableObjectState, fromDurableObjectState } from "./DurableObjectState
 import { fromWebSocket, type DurableWebSocket } from "./DurableObjectWebSocket";
 import * as Entrypoint from "./internal/Entrypoint";
 import * as Runtime from "./internal/Runtime";
+import * as Telemetry from "./internal/Telemetry";
 
 const reservedMethodNames = new Set<string>([
   "constructor",
@@ -29,6 +30,11 @@ type RunOptions = {
 
 const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
 
+const scheduleTelemetryFlush: Effect.Effect<void, never, DurableObjectState> =
+  Telemetry.scheduleTelemetryFlush((flush) =>
+    Effect.flatMap(DurableObjectState, (state) => state.waitUntil(flush)),
+  );
+
 /**
  * Effect type for Durable Object lifecycle and RPC handlers.
  */
@@ -98,7 +104,12 @@ export interface DurableObjectOptions<
    * Object storage if work must happen only once per id.
    */
   readonly initialize?: Effect.Effect<void, unknown, HandlerContext<RRuntime>>;
-  /** Optional RPC methods exposed as Durable Object instance methods. */
+  /**
+   * Optional RPC methods exposed as Durable Object instance methods.
+   *
+   * After every invocation, the configured OTLP flusher is scheduled through
+   * `DurableObjectState.waitUntil`, including when the handler fails.
+   */
   readonly rpc?: Rpc;
   /** Optional fetch handler for HTTP/WebSocket requests. */
   readonly fetch?: Effect.Effect<Response, unknown, FetchContext<RRuntime | REvent>>;
@@ -110,6 +121,12 @@ export interface DurableObjectOptions<
    * the Durable Object's single managed runtime boundary.
    */
   readonly alarms?: Effect.Effect<unknown, unknown, HandlerContext<RRuntime | REvent>>;
+  /**
+   * Optional raw alarm handler.
+   *
+   * After every invocation, the configured OTLP flusher is scheduled through
+   * `DurableObjectState.waitUntil`, including when the handler fails.
+   */
   readonly alarm?: (
     alarmInfo?: globalThis.AlarmInvocationInfo,
   ) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
@@ -193,22 +210,16 @@ export const make = <
     alarm(alarmInfo?: globalThis.AlarmInvocationInfo): Promise<void> | void {
       const logicalAlarms = options.alarms?.pipe(Effect.asVoid);
       const rawAlarm = options.alarm?.(alarmInfo);
-
-      if (logicalAlarms !== undefined && rawAlarm !== undefined) {
-        return this[RunSymbol](
-          Effect.gen(function* () {
-            yield* logicalAlarms;
-            yield* rawAlarm;
-          }),
-        );
-      }
-
-      if (logicalAlarms !== undefined) {
-        return this[RunSymbol](logicalAlarms);
-      }
-
-      if (rawAlarm !== undefined) {
-        return this[RunSymbol](rawAlarm);
+      const alarmEffect =
+        logicalAlarms !== undefined && rawAlarm !== undefined
+          ? Effect.gen(function* () {
+              yield* logicalAlarms;
+              yield* rawAlarm;
+            })
+          : (logicalAlarms ?? rawAlarm);
+
+      if (alarmEffect !== undefined) {
+        return this[RunSymbol](alarmEffect.pipe(Effect.onExit(() => scheduleTelemetryFlush)));
       }
     }
 
@@ -244,6 +255,7 @@ export const make = <
     options.rpc,
     reservedMethodNames,
     (self, effect) => self[RunSymbol](effect),
+    () => scheduleTelemetryFlush,
   );
 
   return Entrypoint.assumeEntrypointClass<DurableObjectClass<Rpc, ROut | REvent>>(

package/src/Worker.ts

@@ -1,21 +1,13 @@
 import { WorkerEntrypoint as CloudflareWorkerEntrypoint } from "cloudflare:workers";
-import {
-  type Cause,
-  Context,
-  Effect,
-  Layer,
-  type ManagedRuntime,
-  Option,
-  type Scope,
-} from "effect";
+import { type Cause, Context, Effect, Layer, type ManagedRuntime, type Scope } from "effect";
 import { HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import { OtlpExporter } from "effect/unstable/observability";
 
 import { WorkerEnvironment, type WorkerEnv } from "./Environment";
 import { fromMessage, fromMessageBatch, type QueueHandler } from "./Queue";
 import type * as RpcDefinition from "./RpcDefinition";
 import * as Entrypoint from "./internal/Entrypoint";
 import * as Runtime from "./internal/Runtime";
+import * as Telemetry from "./internal/Telemetry";
 import { fromExecutionContext } from "./internal/WorkerContext";
 
 /**
@@ -208,7 +200,12 @@ export interface WorkerOptions<
   >;
   /** Queue consumer handler invoked per message batch. */
   readonly queue?: QueueHandler<RRuntime | REvent>;
-  /** Optional RPC methods exposed as class instance methods. */
+  /**
+   * Optional RPC methods exposed as class instance methods.
+   *
+   * After every invocation, the configured OTLP flusher is scheduled through
+   * `WorkerContext.waitUntil`, including when the handler fails.
+   */
   readonly rpc?: Rpc;
 }
 
@@ -292,14 +289,10 @@ const isWorkerOptions = <ROut, REvent, EventLayerError, Rpc extends WorkerRpc<RO
  * (including streaming bodies still being consumed). It is a no-op when the
  * context does not contain an `OtlpExporter.Flusher`.
  */
-const scheduleTelemetryFlush: Effect.Effect<void, never, WorkerContext> = Effect.flatMap(
-  Effect.serviceOption(OtlpExporter.Flusher),
-  Option.match({
-    onNone: () => Effect.void,
-    onSome: (flusher) =>
-      Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flusher.flush)),
-  }),
-);
+const scheduleTelemetryFlush: Effect.Effect<void, never, WorkerContext> =
+  Telemetry.scheduleTelemetryFlush((flush) =>
+    Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flush)),
+  );
 
 /**
  * Creates a Cloudflare worker class backed by a single managed Effect runtime.
@@ -424,6 +417,7 @@ export function make<
     options.rpc,
     reservedMethodNames,
     (self, effect) => self[RunSymbol](effect),
+    () => scheduleTelemetryFlush,
   );
 
   return Entrypoint.assumeEntrypointClass<WorkerClass<Rpc, ROut | REvent>>(EffectWorker);

package/src/internal/Entrypoint.ts

@@ -19,6 +19,7 @@ export const defineEntrypointRpcMethods = <Self>(
   rpc: EntrypointRpc | undefined,
   reservedMethodNames: ReadonlySet<string>,
   run: (self: Self, effect: Effect.Effect<any, any, any>) => Promise<unknown>,
+  onExit?: (self: Self) => Effect.Effect<void, never, any>,
 ): void => {
   const methods = rpc ?? {};
 
@@ -28,11 +29,13 @@ export const defineEntrypointRpcMethods = <Self>(
     Object.defineProperty(prototype, key, {
       enumerable: true,
       value(this: Self, ...args: AnyArgs) {
+        const handler = Effect.suspend(() => method(...args)).pipe(
+          Effect.mapError(RpcDefinition.encodeWireError),
+        );
+
         return run(
           this,
-          Effect.suspend(() => method(...args)).pipe(
-            Effect.mapError(RpcDefinition.encodeWireError),
-          ),
+          onExit === undefined ? handler : handler.pipe(Effect.onExit(() => onExit(this))),
         );
       },
     });

package/src/internal/Telemetry.ts

@@ -0,0 +1,27 @@
+import { Effect, Option } from "effect";
+import { OtlpExporter } from "effect/unstable/observability";
+
+const logFlushFailure = Effect.logError("Telemetry flush failed").pipe(Effect.ignoreCause);
+
+const logFlushSchedulingFailure = Effect.logError("Telemetry flush scheduling failed").pipe(
+  Effect.ignoreCause,
+);
+
+/**
+ * Schedules a configured OTLP flusher through the current Cloudflare event.
+ */
+export const scheduleTelemetryFlush = <R>(
+  waitUntil: (flush: Effect.Effect<void>) => Effect.Effect<void, never, R>,
+): Effect.Effect<void, never, R> =>
+  Effect.gen(function* () {
+    const flusher = yield* Effect.serviceOption(OtlpExporter.Flusher);
+
+    if (Option.isNone(flusher)) {
+      return;
+    }
+
+    // Exporters and platform schedulers are foreign boundaries. Preserve a
+    // useful diagnostic without retaining their arbitrary failure causes in
+    // logs, where payloads, headers, or credentials could otherwise escape.
+    yield* waitUntil(flusher.value.flush.pipe(Effect.catchCause(() => logFlushFailure)));
+  }).pipe(Effect.catchCause(() => logFlushSchedulingFailure));