@krak-stack/registry 0.1.34 → 0.1.35

package/dist/services/opentelemetry/api.js

@@ -1,5 +1,5 @@
 // ../../src/services/opentelemetry/api.ts
-import { Config, Effect, Layer } from "effect";
+import { Config, Effect, Layer, Schema } from "effect";
 import {
   FetchHttpClient,
   HttpClient,
@@ -17,6 +17,7 @@ var otlpProxyPaths = [
   "/api/otel/v1/metrics",
   "/api/otel/v1/logs"
 ];
+var exporterConfig = (signal) => Config.schema(Config.Array(Schema.String), `OTEL_${signal}_EXPORTER`).pipe(Config.map((exporters) => exporters.map((exporter) => exporter.toLowerCase().trim())), Config.withDefault([]));
 var proxyOtlp = (baseUrl, signal) => Effect.gen(function* () {
   const incoming = yield* HttpServerRequest.HttpServerRequest;
   const client = yield* HttpClient.HttpClient;
@@ -33,7 +34,15 @@ var proxyOtlp = (baseUrl, signal) => Effect.gen(function* () {
     }
   });
 }).pipe(Effect.withTracerEnabled(false), HttpMiddleware.withLoggerDisabled, Effect.catch((error) => Effect.logError("Failed to proxy browser telemetry", error).pipe(Effect.as(HttpServerResponse.empty({ status: 502 })))), Effect.provide(FetchHttpClient.layer));
-var otlpProxyLayer = Layer.unwrap(Effect.map(Config.url("OTEL_COLLECTOR_PROXY_URL").pipe(Config.withDefault(new URL("http://localhost:4318"))), (baseUrl) => Layer.mergeAll(HttpRouter.add("POST", otlpProxyPaths[0], proxyOtlp(baseUrl, "traces")), HttpRouter.add("POST", otlpProxyPaths[1], proxyOtlp(baseUrl, "metrics")), HttpRouter.add("POST", otlpProxyPaths[2], proxyOtlp(baseUrl, "logs")))));
+var otlpProxyLayer = Layer.unwrap(Effect.gen(function* () {
+  const baseUrl = yield* Config.url("OTEL_EXPORTER_OTLP_ENDPOINT");
+  const exporters = yield* Config.all({
+    logs: exporterConfig("LOGS"),
+    metrics: exporterConfig("METRICS"),
+    traces: exporterConfig("TRACES")
+  });
+  return Layer.mergeAll(exporters.traces.includes("otlp") ? HttpRouter.add("POST", otlpProxyPaths[0], proxyOtlp(baseUrl, "traces")) : Layer.empty, exporters.metrics.includes("otlp") ? HttpRouter.add("POST", otlpProxyPaths[1], proxyOtlp(baseUrl, "metrics")) : Layer.empty, exporters.logs.includes("otlp") ? HttpRouter.add("POST", otlpProxyPaths[2], proxyOtlp(baseUrl, "logs")) : Layer.empty);
+}));
 var serverServices = HttpServer.layerServices.pipe(Layer.provideMerge(HttpMiddleware.layerTracerDisabledForUrls(otlpProxyPaths)));
 
 class HttpApiOtlp {

package/dist/services/opentelemetry/browser.d.ts

@@ -1,10 +1,18 @@
 import { Layer } from "effect";
-import { Otlp } from "effect/unstable/observability";
+import { type Otlp, OtlpExporter, OtlpLogger, OtlpMetrics, OtlpTracer } from "effect/unstable/observability";
+type OtlpOptions = Parameters<typeof Otlp.layerJson>[0];
+type SignalOptions<Options> = Omit<Options, "url" | "resource" | "headers">;
+export interface BrowserOtlpOptions {
+    readonly serviceName: string;
+    readonly serviceVersion?: string;
+    readonly attributes?: NonNullable<OtlpOptions["resource"]>["attributes"];
+    readonly baseUrl?: string;
+    readonly headers?: OtlpOptions["headers"];
+    readonly traces?: false | SignalOptions<Parameters<typeof OtlpTracer.layer>[0]>;
+    readonly metrics?: false | SignalOptions<Parameters<typeof OtlpMetrics.layer>[0]>;
+    readonly logs?: false | SignalOptions<Parameters<typeof OtlpLogger.layer>[0]>;
+}
 export declare class BrowserOtlp {
-    static readonly layer: ({ attributes, baseUrl, serviceName, serviceVersion, ...options }: Omit<Parameters<typeof Otlp.layerJson>[0], "baseUrl" | "resource"> & {
-        readonly serviceName: string;
-        readonly serviceVersion?: string;
-        readonly attributes?: NonNullable<Parameters<typeof Otlp.layerJson>[0]["resource"]>["attributes"];
-        readonly baseUrl?: string;
-    }) => Layer.Layer<never, never, never>;
+    static readonly layer: ({ attributes, baseUrl, logs, metrics, serviceName, serviceVersion, traces, headers, }: BrowserOtlpOptions) => Layer.Layer<OtlpExporter.Flusher, never, never>;
 }
+export {};

package/dist/services/opentelemetry/browser.js

@@ -1,7 +1,13 @@
 // ../../src/services/opentelemetry/browser.ts
-import { Effect, Layer, Predicate, Schema, Stream } from "effect";
-import { FetchHttpClient } from "effect/unstable/http";
-import { Otlp } from "effect/unstable/observability";
+import { Effect, FiberSet, Layer, Predicate, Schema, Stream } from "effect";
+import { FetchHttpClient, HttpClientRequest } from "effect/unstable/http";
+import {
+  OtlpExporter,
+  OtlpLogger,
+  OtlpMetrics,
+  OtlpSerialization,
+  OtlpTracer
+} from "effect/unstable/observability";
 
 class BrowserReportedError extends Schema.TaggedError()("BrowserReportedError", {
   type: Schema.Literals(["window.error", "unhandledrejection"]),
@@ -10,6 +16,8 @@ class BrowserReportedError extends Schema.TaggedError()("BrowserReportedError",
 }) {
 }
 var reportBrowserException = (exception) => Effect.fail(exception).pipe(Effect.withSpan("browser.exception", {
+  root: true,
+  sampled: true,
   attributes: {
     "exception.type": exception.type,
     "exception.message": exception.message,
@@ -36,23 +44,64 @@ var BrowserExceptionTrackingLive = Layer.effectDiscard(Stream.merge(Stream.fromE
     message: "Unhandled promise rejection"
   });
 }))).pipe(Stream.runForEach(reportBrowserException), Effect.forkScoped));
+var BrowserLifecycleFlushingLive = Layer.effectDiscard(Effect.gen(function* () {
+  const flusher = yield* OtlpExporter.Flusher;
+  const fibers = yield* FiberSet.make();
+  const run = yield* FiberSet.runtime(fibers)();
+  const flush = () => {
+    run(flusher.flush.pipe(Effect.provideService(FetchHttpClient.RequestInit, {
+      keepalive: true
+    })));
+  };
+  const onVisibilityChange = () => {
+    if (document.visibilityState === "hidden")
+      flush();
+  };
+  yield* Effect.acquireRelease(Effect.sync(() => {
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    globalThis.addEventListener("pagehide", flush);
+  }), () => Effect.sync(() => {
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+    globalThis.removeEventListener("pagehide", flush);
+  }));
+}));
 
 class BrowserOtlp {
   static layer = ({
     attributes,
     baseUrl = "/api/otel",
+    logs = false,
+    metrics = false,
     serviceName,
     serviceVersion,
-    ...options
-  }) => BrowserExceptionTrackingLive.pipe(Layer.provideMerge(Otlp.layerJson({
-    tracerExportInterval: "5 seconds",
-    metricsExportInterval: "30 seconds",
-    loggerExcludeLogSpans: true,
-    loggerMergeWithExisting: true,
-    ...options,
-    baseUrl,
-    resource: { attributes, serviceName, serviceVersion }
-  }).pipe(Layer.provide(FetchHttpClient.layer))));
+    traces = {},
+    headers
+  }) => {
+    const resource = { attributes, serviceName, serviceVersion };
+    const request = HttpClientRequest.get(baseUrl);
+    const signalUrl = (signal) => HttpClientRequest.appendUrl(request, `/v1/${signal}`).url;
+    const exporters = Layer.mergeAll(OtlpExporter.layerFlusher, traces !== false ? OtlpTracer.layer({
+      exportInterval: "30 seconds",
+      ...traces,
+      url: signalUrl("traces"),
+      resource,
+      headers
+    }) : Layer.empty, metrics !== false ? OtlpMetrics.layer({
+      exportInterval: "60 seconds",
+      ...metrics,
+      url: signalUrl("metrics"),
+      resource,
+      headers
+    }) : Layer.empty, logs !== false ? OtlpLogger.layer({
+      excludeLogSpans: true,
+      mergeWithExisting: true,
+      ...logs,
+      url: signalUrl("logs"),
+      resource,
+      headers
+    }) : Layer.empty).pipe(Layer.provide(OtlpSerialization.layerJson), Layer.provide(FetchHttpClient.layer));
+    return Layer.mergeAll(BrowserLifecycleFlushingLive, traces !== false ? BrowserExceptionTrackingLive : Layer.empty).pipe(Layer.provideMerge(exporters));
+  };
 }
 export {
   BrowserOtlp

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krak-stack/registry",
-  "version": "0.1.34",
+  "version": "0.1.35",
   "description": "Tree-shakable KrakStack components and Effect services.",
   "license": "MIT",
   "repository": {