@opencode-ai/util 0.0.0-next-17081 → 0.0.0-next-17084

package/dist/observability/otlp.d.ts

@@ -1,4 +1,4 @@
-import { Layer } from "effect";
+import { Effect, Layer, Scope } from "effect";
 export interface Options {
     readonly endpoint?: string;
     readonly headers?: string;
@@ -13,6 +13,6 @@ export declare function resource(app?: App): {
     serviceVersion: string;
     attributes: Record<string, string>;
 };
-export declare function loggers(options: Options | undefined, app: App): import("effect/Effect").Effect<import("effect/Logger").Logger<unknown, void>, never, import("effect/unstable/http/HttpClient").HttpClient | import("effect/Scope").Scope | import("effect/unstable/observability/OtlpSerialization").OtlpSerialization>[];
-export declare function tracingLayer(options: Options | undefined, app: App): Promise<Layer.Layer<never, never, never>>;
+export declare function loggers(options: Options | undefined, app: App): Effect.Effect<import("effect/Logger").Logger<unknown, void>, never, import("effect/unstable/http/HttpClient").HttpClient | Scope.Scope | import("effect/unstable/observability/OtlpSerialization").OtlpSerialization>[];
+export declare const tracingLayer: (options: Options | undefined, app: App) => Effect.Effect<Layer.Layer<never, never, never>, never, never>;
 export * as Otlp from "./otlp.js";

package/dist/observability/otlp.js

@@ -1,4 +1,4 @@
-import { Layer } from "effect";
+import { Effect, Layer, Scope } from "effect";
 import { OtlpLogger } from "effect/unstable/observability";
 import { runID } from "./shared.js";
 function parseHeaders(value) {
@@ -50,24 +50,27 @@ export function loggers(options, app) {
         }),
     ];
 }
-export async function tracingLayer(options, app) {
+export const tracingLayer = Effect.fnUntraced(function* (options, app) {
     if (!options?.endpoint)
         return Layer.empty;
-    const NodeSdk = await import("@effect/opentelemetry/NodeSdk");
-    const OTLP = await import("@opentelemetry/exporter-trace-otlp-http");
-    const SdkBase = await import("@opentelemetry/sdk-trace-base");
-    const { AsyncLocalStorageContextManager } = await import("@opentelemetry/context-async-hooks");
-    const { context } = await import("@opentelemetry/api");
+    const [{ layer }, { OTLPTraceExporter }, { BatchSpanProcessor }, { AsyncLocalStorageContextManager }, { context }] = yield* Effect.all([
+        Effect.promise(() => import("@effect/opentelemetry/NodeSdk")),
+        Effect.promise(() => import("@opentelemetry/exporter-trace-otlp-http")),
+        Effect.promise(() => import("@opentelemetry/sdk-trace-base")),
+        Effect.promise(() => import("@opentelemetry/context-async-hooks")),
+        Effect.promise(() => import("@opentelemetry/api")),
+    ], { concurrency: "unbounded" });
     // The Effect Node SDK does not register a global context manager, but the AI SDK uses it to parent spans.
     const manager = new AsyncLocalStorageContextManager();
     manager.enable();
     context.setGlobalContextManager(manager);
-    return NodeSdk.layer(() => ({
+    const tracing = layer(() => ({
         resource: resource(app),
-        spanProcessor: new SdkBase.BatchSpanProcessor(new OTLP.OTLPTraceExporter({
+        spanProcessor: new BatchSpanProcessor(new OTLPTraceExporter({
             url: `${options.endpoint}/v1/traces`,
             headers: parseHeaders(options.headers),
         })),
     }));
-}
+    return Layer.effectContext(Effect.acquireRelease(Scope.make(), (scope, exit) => Scope.close(scope, exit).pipe(Effect.ignoreCause)).pipe(Effect.flatMap((scope) => Layer.buildWithScope(tracing, scope))));
+});
 export * as Otlp from "./otlp.js";

package/dist/observability.js

@@ -25,7 +25,7 @@ export function layer(options = {
     const local = Logger.layer(Logging.loggers(app.channel === "local", app.channel), { mergeWithExisting: false }).pipe(Layer.provide(NodeFileSystem.layer), Layer.orDie, Layer.merge(Layer.succeed(References.MinimumLogLevel, Logging.minimumLogLevel())));
     return Layer.unwrap(Effect.gen(function* () {
         const logs = Logger.layer([...Logging.loggers(app.channel === "local", app.channel), ...Otlp.loggers(options, app)], { mergeWithExisting: false }).pipe(Layer.provide(NodeFileSystem.layer), Layer.provide(OtlpSerialization.layerJson), Layer.provide(FetchHttpClient.layer), Layer.orDie, Layer.merge(Layer.succeed(References.MinimumLogLevel, Logging.minimumLogLevel())));
-        return Layer.merge(logs, yield* Effect.promise(() => Otlp.tracingLayer(options, app)));
+        return Layer.merge(logs, yield* Otlp.tracingLayer(options, app));
     })).pipe(Layer.catchCause(() => local));
 }
 export const node = LayerNode.make({ name: "observability", layer: layer(), deps: [] });

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/util",
-  "version": "0.0.0-next-17081",
+  "version": "0.0.0-next-17084",
   "type": "module",
   "license": "MIT",
   "repository": {