@krak-stack/registry 0.1.39 → 0.1.41

package/dist/services/opentelemetry/browser.js

@@ -1,21 +1,153 @@
 // ../../src/services/opentelemetry/browser.ts
-import { Effect, FiberSet, Layer, Predicate, Schema, Stream } from "effect";
+import {
+  Context as Context2,
+  Effect as Effect2,
+  FiberSet,
+  Layer as Layer2,
+  Predicate,
+  Ref,
+  References as References2,
+  Schema as Schema3,
+  Stream
+} from "effect";
 import { FetchHttpClient, HttpClientRequest } from "effect/http";
 import {
-  OtlpExporter,
+  OtlpExporter as OtlpExporter2,
   OtlpLogger,
   OtlpMetrics,
-  OtlpSerialization,
+  OtlpSerialization as OtlpSerialization2,
   OtlpTracer
 } from "effect/observability";
 
-class BrowserReportedError extends Schema.TaggedError()("BrowserReportedError", {
-  type: Schema.Literals(["window.error", "unhandledrejection"]),
-  message: Schema.String,
-  stack: Schema.optional(Schema.String)
+// ../../src/services/opentelemetry/events.ts
+import {
+  Clock,
+  Context,
+  DateTime,
+  Effect,
+  Layer,
+  Option,
+  References,
+  Schema as Schema2
+} from "effect";
+import {
+  OtlpExporter,
+  OtlpResource,
+  OtlpSerialization
+} from "effect/observability";
+
+// ../../src/services/opentelemetry/schema.ts
+import { Schema } from "effect";
+var EventAttributeValue = Schema.Union([
+  Schema.String,
+  Schema.Finite,
+  Schema.Boolean,
+  Schema.Array(Schema.String),
+  Schema.Array(Schema.Finite),
+  Schema.Array(Schema.Boolean)
+]);
+var EventAttributesSchema = Schema.Record(Schema.String, EventAttributeValue).annotate({ identifier: "EventAttributes" });
+var EventOptionsSchema = Schema.Struct({
+  userId: Schema.optional(Schema.NonEmptyString),
+  anonymousId: Schema.optional(Schema.NonEmptyString),
+  sessionId: Schema.optional(Schema.NonEmptyString),
+  messageId: Schema.optional(Schema.NonEmptyString),
+  timestamp: Schema.optional(Schema.DateTimeUtc),
+  context: Schema.optional(EventAttributesSchema)
+}).annotate({ identifier: "EventOptions" });
+var TelemetryEvent = Schema.Struct({
+  name: Schema.NonEmptyString,
+  properties: Schema.optional(EventAttributesSchema),
+  options: Schema.optional(EventOptionsSchema)
+}).annotate({ identifier: "TelemetryEvent" });
+var PageEvent = Schema.Struct({
+  name: Schema.optional(Schema.NonEmptyString),
+  category: Schema.optional(Schema.NonEmptyString),
+  path: Schema.optional(Schema.NonEmptyString),
+  properties: Schema.optional(EventAttributesSchema),
+  options: Schema.optional(EventOptionsSchema)
+}).annotate({ identifier: "PageEvent" });
+var BrowserIdentity = Schema.Struct({
+  userId: Schema.optional(Schema.NonEmptyString),
+  organizationId: Schema.optional(Schema.NonEmptyString)
+}).annotate({ identifier: "BrowserTelemetryIdentity" });
+
+// ../../src/services/opentelemetry/events.ts
+class OtlpEvents extends Context.Service()("krakstack/opentelemetry/Events") {
+  static disabledLayer = Layer.succeed(this, { push: () => {} });
+  static layer = (options) => Layer.effect(this, Effect.gen(function* () {
+    const serialization = yield* OtlpSerialization.OtlpSerialization;
+    const resource = yield* OtlpResource.fromConfig(options.resource);
+    return yield* OtlpExporter.make({
+      ...options,
+      label: "OtlpEvents",
+      body: (logRecords) => [
+        serialization.logs({
+          resourceLogs: [
+            {
+              resource,
+              scopeLogs: [
+                {
+                  scope: { name: "krakstack.events" },
+                  logRecords
+                }
+              ]
+            }
+          ]
+        }),
+        Effect.void
+      ]
+    });
+  }));
+}
+var track = Effect.fnUntraced(function* (name, properties, options) {
+  const event = yield* Schema2.decodeUnknownEffect(TelemetryEvent)({
+    name,
+    properties,
+    options
+  });
+  const events = yield* OtlpEvents;
+  const clock = yield* Clock.Clock;
+  const observedTime = clock.currentTimeNanosUnsafe().toString();
+  const timestamp = event.options?.timestamp ? (BigInt(DateTime.toEpochMillis(event.options.timestamp)) * 1000000n).toString() : observedTime;
+  const span = yield* Effect.currentSpan.pipe(Effect.option);
+  const attributes = { ...event.options?.context, ...event.properties };
+  if (event.options?.userId)
+    attributes["user.id"] = event.options.userId;
+  if (event.options?.anonymousId)
+    attributes["analytics.anonymous_id"] = event.options.anonymousId;
+  if (event.options?.sessionId)
+    attributes["session.id"] = event.options.sessionId;
+  if (event.options?.messageId)
+    attributes["log.record.uid"] = event.options.messageId;
+  const annotations = yield* References.CurrentLogAnnotations;
+  events.push({
+    eventName: event.name,
+    timeUnixNano: timestamp,
+    observedTimeUnixNano: observedTime,
+    severityNumber: 9,
+    attributes: OtlpResource.entriesToAttributes(Object.entries({
+      ...attributes,
+      ...annotations
+    })),
+    droppedAttributesCount: 0,
+    traceId: Option.isSome(span) ? span.value.traceId : undefined,
+    spanId: Option.isSome(span) ? span.value.spanId : undefined
+  });
+});
+
+// ../../src/services/opentelemetry/browser.ts
+class BrowserIdentityState extends Context2.Service()("krakstack/opentelemetry/BrowserIdentity") {
+  static layer = Layer2.effect(this, Ref.make({}));
+}
+
+class BrowserReportedError extends Schema3.TaggedError()("BrowserReportedError", {
+  type: Schema3.Literals(["window.error", "unhandledrejection"]),
+  message: Schema3.String,
+  stack: Schema3.optional(Schema3.String)
 }) {
 }
-var reportBrowserException = (exception) => Effect.fail(exception).pipe(Effect.withSpan("browser.exception", {
+var reportBrowserException = (exception) => Effect2.fail(exception).pipe(Effect2.withSpan("browser.exception", {
   root: true,
   sampled: true,
   attributes: {
@@ -23,8 +155,8 @@ var reportBrowserException = (exception) => Effect.fail(exception).pipe(Effect.w
     "exception.message": exception.message,
     "exception.stacktrace": exception.stack ?? ""
   }
-}), Effect.ignoreCause);
-var BrowserExceptionTrackingLive = Layer.effectDiscard(Stream.merge(Stream.fromEventListener(globalThis, "error", {
+}), Effect2.ignoreCause);
+var BrowserExceptionTrackingLive = Layer2.effectDiscard(Stream.merge(Stream.fromEventListener(globalThis, "error", {
   bufferSize: 100
 }).pipe(Stream.map((event) => {
   const error = event.error;
@@ -43,13 +175,13 @@ var BrowserExceptionTrackingLive = Layer.effectDiscard(Stream.merge(Stream.fromE
     type: "unhandledrejection",
     message: "Unhandled promise rejection"
   });
-}))).pipe(Stream.runForEach(reportBrowserException), Effect.forkScoped));
-var BrowserLifecycleFlushingLive = Layer.effectDiscard(Effect.gen(function* () {
-  const flusher = yield* OtlpExporter.Flusher;
+}))).pipe(Stream.runForEach(reportBrowserException), Effect2.forkScoped));
+var BrowserLifecycleFlushingLive = Layer2.effectDiscard(Effect2.gen(function* () {
+  const flusher = yield* OtlpExporter2.Flusher;
   const fibers = yield* FiberSet.make();
   const run = yield* FiberSet.runtime(fibers)();
   const flush = () => {
-    run(flusher.flush.pipe(Effect.provideService(FetchHttpClient.RequestInit, {
+    run(flusher.flush.pipe(Effect2.provideService(FetchHttpClient.RequestInit, {
       keepalive: true
     })));
   };
@@ -57,50 +189,164 @@ var BrowserLifecycleFlushingLive = Layer.effectDiscard(Effect.gen(function* () {
     if (document.visibilityState === "hidden")
       flush();
   };
-  yield* Effect.acquireRelease(Effect.sync(() => {
+  yield* Effect2.acquireRelease(Effect2.sync(() => {
     document.addEventListener("visibilitychange", onVisibilityChange);
     globalThis.addEventListener("pagehide", flush);
-  }), () => Effect.sync(() => {
+  }), () => Effect2.sync(() => {
     document.removeEventListener("visibilitychange", onVisibilityChange);
     globalThis.removeEventListener("pagehide", flush);
   }));
 }));
+var browserEffects = {
+  identify: Effect2.fnUntraced(function* (input) {
+    const identity = yield* Schema3.decodeUnknownEffect(BrowserIdentity)(input === null ? {} : input);
+    const state = yield* BrowserIdentityState;
+    yield* Ref.set(state, identity);
+  }),
+  track: Effect2.fnUntraced(function* (name, properties, options) {
+    const state = yield* BrowserIdentityState;
+    const identity = yield* Ref.get(state);
+    const annotations = {};
+    if (identity.userId)
+      annotations["user.id"] = identity.userId;
+    if (identity.organizationId)
+      annotations["organization.id"] = identity.organizationId;
+    const scoped = yield* References2.CurrentLogAnnotations;
+    yield* track(name, properties, options).pipe(Effect2.annotateLogs({ ...annotations, ...scoped }));
+  }),
+  page: Effect2.fnUntraced(function* (input = {}) {
+    const page = yield* Schema3.decodeUnknownEffect(PageEvent)(input);
+    const properties = { ...page.properties };
+    if (page.name)
+      properties["analytics.page.name"] = page.name;
+    if (page.category)
+      properties["analytics.page.category"] = page.category;
+    properties["url.path"] = (page.path ?? globalThis.location.pathname).split(/[?#]/, 1)[0] ?? "/";
+    yield* browserEffects.track("browser.page_view", properties, page.options);
+  })
+};
+var browserClients = [];
+var runBrowser = (program) => Effect2.suspend(() => {
+  const client = browserClients.at(-1);
+  if (!client)
+    return Effect2.void;
+  return program.pipe(Effect2.provideService(BrowserIdentityState, client.identity), Effect2.provideService(OtlpEvents, client.events));
+});
+var BrowserClientLive = Layer2.effectDiscard(Effect2.gen(function* () {
+  const identity = yield* BrowserIdentityState;
+  const events = yield* OtlpEvents;
+  yield* Effect2.acquireRelease(Effect2.sync(() => {
+    const client = { identity, events };
+    browserClients.push(client);
+    return client;
+  }), (client) => Effect2.sync(() => {
+    const index = browserClients.indexOf(client);
+    if (index !== -1)
+      browserClients.splice(index, 1);
+  }));
+}));
+var pageViewListeners = new Set;
+var stopPageViewTracking;
+var subscribePageViews = (listener) => {
+  if (pageViewListeners.size === 0) {
+    const history = globalThis.history;
+    const pushState = history.pushState;
+    const replaceState = history.replaceState;
+    const notify = () => {
+      for (const onPage of pageViewListeners)
+        onPage();
+    };
+    const trackedPushState = (...args) => {
+      pushState.apply(history, args);
+      notify();
+    };
+    const trackedReplaceState = (...args) => {
+      replaceState.apply(history, args);
+      notify();
+    };
+    history.pushState = trackedPushState;
+    history.replaceState = trackedReplaceState;
+    globalThis.addEventListener("popstate", notify);
+    stopPageViewTracking = () => {
+      globalThis.removeEventListener("popstate", notify);
+      if (history.pushState === trackedPushState)
+        history.pushState = pushState;
+      if (history.replaceState === trackedReplaceState)
+        history.replaceState = replaceState;
+    };
+  }
+  pageViewListeners.add(listener);
+  return () => {
+    pageViewListeners.delete(listener);
+    if (pageViewListeners.size === 0) {
+      stopPageViewTracking?.();
+      stopPageViewTracking = undefined;
+    }
+  };
+};
+var BrowserPageViewsLive = Layer2.effectDiscard(Effect2.gen(function* () {
+  const fibers = yield* FiberSet.make();
+  const run = yield* FiberSet.runtime(fibers)();
+  let previousPath = globalThis.location.pathname;
+  yield* Effect2.acquireRelease(Effect2.sync(() => subscribePageViews(() => {
+    const path = globalThis.location.pathname;
+    if (path === previousPath)
+      return;
+    previousPath = path;
+    run(browserEffects.page({ path }).pipe(Effect2.ignore));
+  })), (unsubscribe) => Effect2.sync(unsubscribe));
+  yield* browserEffects.page({ path: previousPath }).pipe(Effect2.ignore);
+}));
 
 class BrowserOtlp {
+  static identify = (identity) => runBrowser(browserEffects.identify(identity)).pipe(Effect2.catch(() => Effect2.logWarning("Invalid browser telemetry identity; keeping previous identity")));
+  static track = (name, properties, options) => runBrowser(browserEffects.track(name, properties, options));
+  static page = (options) => runBrowser(browserEffects.page(options));
+  static pageView = BrowserOtlp.page;
   static layer = ({
     attributes,
     baseUrl = "/api/otel",
     logs = false,
+    events = false,
     metrics = false,
     serviceName,
     serviceVersion,
     traces = {},
     headers
   }) => {
+    const { pageViews = true, ...eventOptions } = events === false ? {} : events;
     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({
+    const exporters = Layer2.mergeAll(OtlpExporter2.layerFlusher, events !== false ? OtlpEvents.layer({
+      exportInterval: "30 seconds",
+      maxBatchSize: 100,
+      shutdownTimeout: "3 seconds",
+      ...eventOptions,
+      url: signalUrl("logs"),
+      resource,
+      headers
+    }) : OtlpEvents.disabledLayer, traces !== false ? OtlpTracer.layer({
       exportInterval: "30 seconds",
       ...traces,
       url: signalUrl("traces"),
       resource,
       headers
-    }) : Layer.empty, metrics !== false ? OtlpMetrics.layer({
+    }) : Layer2.empty, metrics !== false ? OtlpMetrics.layer({
       exportInterval: "60 seconds",
       ...metrics,
       url: signalUrl("metrics"),
       resource,
       headers
-    }) : Layer.empty, logs !== false ? OtlpLogger.layer({
+    }) : Layer2.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));
+    }) : Layer2.empty).pipe(Layer2.provideMerge(OtlpExporter2.layerFlusher), Layer2.provide(OtlpSerialization2.layerJson), Layer2.provide(FetchHttpClient.layer));
+    return Layer2.mergeAll(BrowserClientLive, BrowserLifecycleFlushingLive, events !== false && pageViews ? BrowserPageViewsLive : Layer2.empty, traces !== false ? BrowserExceptionTrackingLive : Layer2.empty).pipe(Layer2.provideMerge(Layer2.merge(BrowserIdentityState.layer, exporters)));
   };
 }
 export {

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

@@ -0,0 +1,37 @@
+import { Context, DateTime, Effect, Layer, Schema } from "effect";
+import { OtlpExporter, OtlpResource, OtlpSerialization } from "effect/observability";
+type ExporterOptions = Pick<Parameters<typeof OtlpExporter.make>[0], "url" | "headers" | "exportInterval" | "maxBatchSize" | "shutdownTimeout"> & {
+    readonly resource?: Parameters<typeof OtlpResource.fromConfig>[0];
+};
+export type EventExportOptions = Partial<Pick<ExporterOptions, "exportInterval" | "maxBatchSize" | "shutdownTimeout">>;
+declare const OtlpEvents_base: Context.ServiceClass<OtlpEvents, "krakstack/opentelemetry/Events", {
+    readonly push: (record: EventRecord) => void;
+}>;
+export declare class OtlpEvents extends OtlpEvents_base {
+    static readonly disabledLayer: Layer.Layer<OtlpEvents, never, never>;
+    static readonly layer: (options: ExporterOptions) => Layer.Layer<OtlpEvents, never, OtlpExporter.Flusher | import("effect/http/HttpClient").HttpClient | OtlpSerialization.OtlpSerialization>;
+}
+interface EventRecord {
+    readonly eventName: string;
+    readonly timeUnixNano: string;
+    readonly observedTimeUnixNano: string;
+    readonly severityNumber: 9;
+    readonly attributes: ReturnType<typeof OtlpResource.entriesToAttributes>;
+    readonly droppedAttributesCount: 0;
+    readonly traceId?: string;
+    readonly spanId?: string;
+}
+/** Emits an INFO event without creating a tracing span or persisting identity. */
+export declare const track: (name: string, properties?: {
+    readonly [x: string]: string | number | boolean | readonly string[] | readonly number[] | readonly boolean[];
+} | undefined, options?: {
+    readonly userId?: string | undefined;
+    readonly anonymousId?: string | undefined;
+    readonly sessionId?: string | undefined;
+    readonly messageId?: string | undefined;
+    readonly timestamp?: DateTime.Utc | undefined;
+    readonly context?: {
+        readonly [x: string]: string | number | boolean | readonly string[] | readonly number[] | readonly boolean[];
+    } | undefined;
+} | undefined) => Effect.Effect<void, Schema.SchemaError, OtlpEvents>;
+export {};

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

@@ -0,0 +1,44 @@
+import { Schema } from "effect";
+export declare const EventAttributesSchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>, Schema.$Array<Schema.Finite>, Schema.$Array<Schema.Boolean>]>>;
+export declare const EventOptionsSchema: Schema.Struct<{
+    readonly userId: Schema.optional<Schema.NonEmptyString>;
+    readonly anonymousId: Schema.optional<Schema.NonEmptyString>;
+    readonly sessionId: Schema.optional<Schema.NonEmptyString>;
+    readonly messageId: Schema.optional<Schema.NonEmptyString>;
+    readonly timestamp: Schema.optional<Schema.DateTimeUtc>;
+    readonly context: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>, Schema.$Array<Schema.Finite>, Schema.$Array<Schema.Boolean>]>>>;
+}>;
+export declare const TelemetryEvent: Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly properties: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>, Schema.$Array<Schema.Finite>, Schema.$Array<Schema.Boolean>]>>>;
+    readonly options: Schema.optional<Schema.Struct<{
+        readonly userId: Schema.optional<Schema.NonEmptyString>;
+        readonly anonymousId: Schema.optional<Schema.NonEmptyString>;
+        readonly sessionId: Schema.optional<Schema.NonEmptyString>;
+        readonly messageId: Schema.optional<Schema.NonEmptyString>;
+        readonly timestamp: Schema.optional<Schema.DateTimeUtc>;
+        readonly context: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>, Schema.$Array<Schema.Finite>, Schema.$Array<Schema.Boolean>]>>>;
+    }>>;
+}>;
+export declare const PageEvent: Schema.Struct<{
+    readonly name: Schema.optional<Schema.NonEmptyString>;
+    readonly category: Schema.optional<Schema.NonEmptyString>;
+    readonly path: Schema.optional<Schema.NonEmptyString>;
+    readonly properties: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>, Schema.$Array<Schema.Finite>, Schema.$Array<Schema.Boolean>]>>>;
+    readonly options: Schema.optional<Schema.Struct<{
+        readonly userId: Schema.optional<Schema.NonEmptyString>;
+        readonly anonymousId: Schema.optional<Schema.NonEmptyString>;
+        readonly sessionId: Schema.optional<Schema.NonEmptyString>;
+        readonly messageId: Schema.optional<Schema.NonEmptyString>;
+        readonly timestamp: Schema.optional<Schema.DateTimeUtc>;
+        readonly context: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>, Schema.$Array<Schema.Finite>, Schema.$Array<Schema.Boolean>]>>>;
+    }>>;
+}>;
+export type EventAttributes = typeof EventAttributesSchema.Type;
+export type EventOptions = typeof EventOptionsSchema.Type;
+export type PageOptions = typeof PageEvent.Type;
+export declare const BrowserIdentity: Schema.Struct<{
+    readonly userId: Schema.optional<Schema.NonEmptyString>;
+    readonly organizationId: Schema.optional<Schema.NonEmptyString>;
+}>;
+export type BrowserIdentity = typeof BrowserIdentity.Type;

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

@@ -0,0 +1,20 @@
+import { Effect, Layer, Schema } from "effect";
+import { OtlpExporter } from "effect/observability";
+import { OtlpEvents } from "./events.js";
+export type { EventAttributes, EventOptions } from "./schema.js";
+/** Runtime-neutral server telemetry for HTTP applications, workers, and CLIs. */
+export declare class ServerOtlp {
+    static readonly track: (name: string, properties?: {
+        readonly [x: string]: string | number | boolean | readonly string[] | readonly number[] | readonly boolean[];
+    } | undefined, options?: {
+        readonly userId?: string | undefined;
+        readonly anonymousId?: string | undefined;
+        readonly sessionId?: string | undefined;
+        readonly messageId?: string | undefined;
+        readonly timestamp?: import("effect/DateTime").Utc | undefined;
+        readonly context?: {
+            readonly [x: string]: string | number | boolean | readonly string[] | readonly number[] | readonly boolean[];
+        } | undefined;
+    } | undefined) => Effect.Effect<void, Schema.SchemaError, OtlpEvents>;
+    static readonly layer: Layer.Layer<OtlpExporter.Flusher | OtlpEvents, never, never>;
+}

package/dist/services/opentelemetry/server.js

@@ -0,0 +1,154 @@
+// ../../src/services/opentelemetry/server.ts
+import { Config, Effect as Effect2, Layer as Layer2, Schema as Schema3 } from "effect";
+import { FetchHttpClient } from "effect/http";
+import { Otlp, OtlpExporter as OtlpExporter2, OtlpSerialization as OtlpSerialization2 } from "effect/observability";
+
+// ../../src/services/opentelemetry/events.ts
+import {
+  Clock,
+  Context,
+  DateTime,
+  Effect,
+  Layer,
+  Option,
+  References,
+  Schema as Schema2
+} from "effect";
+import {
+  OtlpExporter,
+  OtlpResource,
+  OtlpSerialization
+} from "effect/observability";
+
+// ../../src/services/opentelemetry/schema.ts
+import { Schema } from "effect";
+var EventAttributeValue = Schema.Union([
+  Schema.String,
+  Schema.Finite,
+  Schema.Boolean,
+  Schema.Array(Schema.String),
+  Schema.Array(Schema.Finite),
+  Schema.Array(Schema.Boolean)
+]);
+var EventAttributesSchema = Schema.Record(Schema.String, EventAttributeValue).annotate({ identifier: "EventAttributes" });
+var EventOptionsSchema = Schema.Struct({
+  userId: Schema.optional(Schema.NonEmptyString),
+  anonymousId: Schema.optional(Schema.NonEmptyString),
+  sessionId: Schema.optional(Schema.NonEmptyString),
+  messageId: Schema.optional(Schema.NonEmptyString),
+  timestamp: Schema.optional(Schema.DateTimeUtc),
+  context: Schema.optional(EventAttributesSchema)
+}).annotate({ identifier: "EventOptions" });
+var TelemetryEvent = Schema.Struct({
+  name: Schema.NonEmptyString,
+  properties: Schema.optional(EventAttributesSchema),
+  options: Schema.optional(EventOptionsSchema)
+}).annotate({ identifier: "TelemetryEvent" });
+var PageEvent = Schema.Struct({
+  name: Schema.optional(Schema.NonEmptyString),
+  category: Schema.optional(Schema.NonEmptyString),
+  path: Schema.optional(Schema.NonEmptyString),
+  properties: Schema.optional(EventAttributesSchema),
+  options: Schema.optional(EventOptionsSchema)
+}).annotate({ identifier: "PageEvent" });
+var BrowserIdentity = Schema.Struct({
+  userId: Schema.optional(Schema.NonEmptyString),
+  organizationId: Schema.optional(Schema.NonEmptyString)
+}).annotate({ identifier: "BrowserTelemetryIdentity" });
+
+// ../../src/services/opentelemetry/events.ts
+class OtlpEvents extends Context.Service()("krakstack/opentelemetry/Events") {
+  static disabledLayer = Layer.succeed(this, { push: () => {} });
+  static layer = (options) => Layer.effect(this, Effect.gen(function* () {
+    const serialization = yield* OtlpSerialization.OtlpSerialization;
+    const resource = yield* OtlpResource.fromConfig(options.resource);
+    return yield* OtlpExporter.make({
+      ...options,
+      label: "OtlpEvents",
+      body: (logRecords) => [
+        serialization.logs({
+          resourceLogs: [
+            {
+              resource,
+              scopeLogs: [
+                {
+                  scope: { name: "krakstack.events" },
+                  logRecords
+                }
+              ]
+            }
+          ]
+        }),
+        Effect.void
+      ]
+    });
+  }));
+}
+var track = Effect.fnUntraced(function* (name, properties, options) {
+  const event = yield* Schema2.decodeUnknownEffect(TelemetryEvent)({
+    name,
+    properties,
+    options
+  });
+  const events = yield* OtlpEvents;
+  const clock = yield* Clock.Clock;
+  const observedTime = clock.currentTimeNanosUnsafe().toString();
+  const timestamp = event.options?.timestamp ? (BigInt(DateTime.toEpochMillis(event.options.timestamp)) * 1000000n).toString() : observedTime;
+  const span = yield* Effect.currentSpan.pipe(Effect.option);
+  const attributes = { ...event.options?.context, ...event.properties };
+  if (event.options?.userId)
+    attributes["user.id"] = event.options.userId;
+  if (event.options?.anonymousId)
+    attributes["analytics.anonymous_id"] = event.options.anonymousId;
+  if (event.options?.sessionId)
+    attributes["session.id"] = event.options.sessionId;
+  if (event.options?.messageId)
+    attributes["log.record.uid"] = event.options.messageId;
+  const annotations = yield* References.CurrentLogAnnotations;
+  events.push({
+    eventName: event.name,
+    timeUnixNano: timestamp,
+    observedTimeUnixNano: observedTime,
+    severityNumber: 9,
+    attributes: OtlpResource.entriesToAttributes(Object.entries({
+      ...attributes,
+      ...annotations
+    })),
+    droppedAttributesCount: 0,
+    traceId: Option.isSome(span) ? span.value.traceId : undefined,
+    spanId: Option.isSome(span) ? span.value.spanId : undefined
+  });
+});
+
+// ../../src/services/opentelemetry/server.ts
+var ServerEventsLive = Layer2.unwrap(Effect2.gen(function* () {
+  const disabled = yield* Config.Boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false));
+  const exporters = yield* Config.Array(Schema3.String, "OTEL_LOGS_EXPORTER").pipe(Config.withDefault([]));
+  if (disabled || !exporters.some((value) => value.trim().toLowerCase() === "otlp")) {
+    return OtlpEvents.disabledLayer;
+  }
+  const endpoint = yield* Config.URL("OTEL_EXPORTER_OTLP_LOGS_ENDPOINT").pipe(Config.orElse(() => Config.URL("OTEL_EXPORTER_OTLP_ENDPOINT").pipe(Config.map((url) => {
+    url.pathname += `${url.pathname.endsWith("/") ? "" : "/"}v1/logs`;
+    return url;
+  }))), Config.withDefault(undefined));
+  if (!endpoint) {
+    return OtlpEvents.disabledLayer;
+  }
+  const headersConfig = (name) => Config.Record(Schema3.String, Schema3.StringFromUriComponent, name);
+  const headers = yield* headersConfig("OTEL_EXPORTER_OTLP_LOGS_HEADERS").pipe(Config.orElse(() => headersConfig("OTEL_EXPORTER_OTLP_HEADERS")), Config.withDefault(undefined));
+  return OtlpEvents.layer({
+    url: endpoint.toString(),
+    headers,
+    exportInterval: "1 second",
+    maxBatchSize: 1000,
+    shutdownTimeout: "3 seconds"
+  });
+}).pipe(Effect2.orDie));
+
+class ServerOtlp {
+  static track = track;
+  static layer = Layer2.mergeAll(Otlp.layerFromConfig(), ServerEventsLive).pipe(Layer2.provideMerge(OtlpExporter2.layerFlusher), Layer2.provide(OtlpSerialization2.layerJson), Layer2.provide(FetchHttpClient.layer));
+}
+export {
+  ServerOtlp
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krak-stack/registry",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "description": "Tree-shakable KrakStack components and Effect services.",
   "license": "MIT",
   "repository": {
@@ -49,6 +49,10 @@
       "types": "./dist/services/opentelemetry/browser.d.ts",
       "import": "./dist/services/opentelemetry/browser.js"
     },
+    "./opentelemetry/server": {
+      "types": "./dist/services/opentelemetry/server.d.ts",
+      "import": "./dist/services/opentelemetry/server.js"
+    },
     "./docs": {
       "types": "./dist/lib/docs.d.ts",
       "import": "./dist/lib/docs.js"