live-traces 0.1.0

package/src/Tracer.ts

@@ -0,0 +1,176 @@
+import type { Span } from "effect/Tracer";
+
+/**
+ * LiveTraceLayer — Effect Tracer decorator.
+ *
+ * Wraps whatever base tracer is in DefaultServices (native or OTel).
+ * Intercepts span creation within `LiveTrace.withTrace()` scopes
+ * and emits TraceEvents to a TraceSink.
+ *
+ * - Works standalone (no @effect/opentelemetry needed)
+ * - Works alongside OTel (wraps the OTel tracer, both systems run)
+ * - Zero FiberRef access in Tracer.span() — uses parent chain + attributes
+ *
+ * ## Layer composition: why ordering matters
+ *
+ * `Layer.setTracer` modifies the `currentServices` FiberRef — each call
+ * overwrites the previous tracer. When composing via `Layer.provideMerge`,
+ * the argument (`self`) is built FIRST. In a pipe chain:
+ *
+ * ```
+ * X.pipe(Layer.provideMerge(A), Layer.provideMerge(B))
+ * ```
+ *
+ * Build order: B (outermost self) → A (inner self) → X
+ *
+ * For LiveTraceLayer to wrap OTel's tracer, TelemetryLive must build
+ * BEFORE LiveTraceLayer so that `Effect.tracerWith` captures the OTel
+ * tracer. This means TelemetryLive must be OUTER (later in the pipe)
+ * and LiveTraceLayer must be INNER (earlier in the pipe):
+ *
+ * ```ts
+ * X.pipe(
+ *   Layer.provideMerge(makeLiveTraceLayer()), // inner: builds 2nd, wraps OTel
+ *   Layer.provideMerge(TelemetryLive),        // outer: builds 1st, sets OTel
+ * )
+ * ```
+ */
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Tracer from "effect/Tracer";
+
+import { TraceSink, type TraceSinkHandle } from "./Sink.js";
+import { LIVE_TRACE, LIVE_TRACE_ID, LIVE_TRACE_SCOPE_ID, LIVE_TRACE_SCOPE_TYPE, type TraceScope } from "./types.js";
+import { isWrappedSpan, shouldExclude, WrappedSpan } from "./WrappedSpan.js";
+
+/**
+ * Creates a LiveTraceLayer that wraps the current tracer.
+ *
+ * **Important**: This layer reads the current tracer from the FiberRef
+ * at build time via `Effect.tracerWith`. For it to wrap the OTel tracer,
+ * TelemetryLive (or any layer that calls `Layer.setTracer`) must be
+ * built BEFORE this layer. In a `Layer.provideMerge` pipe chain, that
+ * means TelemetryLive should appear AFTER (outer) this layer:
+ *
+ * @example
+ * ```ts
+ * const EnvLayer = ServerLive.pipe(
+ *   Layer.provideMerge(ServicesLayer),
+ *   // LiveTraceLayer BEFORE TelemetryLive in pipe = builds AFTER
+ *   Layer.provideMerge(makeLiveTraceLayer()),
+ *   // TelemetryLive AFTER in pipe = builds FIRST (sets OTel tracer)
+ *   Layer.provideMerge(TelemetryLive),
+ * )
+ * ```
+ */
+export const LiveTraceLayer: Layer.Layer<never, never, TraceSink> = Layer.unwrapEffect(
+    Effect.gen(function* () {
+        // Capture the current tracer from DefaultServices FiberRef.
+        // When composed correctly (TelemetryLive outer, us inner),
+        // this captures the OTel tracer. When standalone, this
+        // captures the native tracer.
+        const baseTracer = yield* Effect.tracerWith(Effect.succeed);
+        const sink = yield* TraceSink;
+
+        const wrappedTracer = Tracer.make({
+            span(name, parent, context, links, startTime, kind, options) {
+                // Create the inner span via the base tracer (OTel or native)
+                const innerSpan = baseTracer.span(name, parent, context, links, startTime, kind, options);
+
+                // Should we exclude this span from live tracing?
+                if (shouldExclude(options?.attributes)) {
+                    return innerSpan;
+                }
+
+                // Check: is this the root of a live-traced scope?
+                if (options?.attributes?.[LIVE_TRACE] === true) {
+                    return createRootWrappedSpan(innerSpan, sink, options.attributes);
+                }
+
+                // Check: is the parent a WrappedSpan? (inside a traced scope)
+                if (Option.isSome(parent) && isWrappedSpan(parent.value)) {
+                    const parentWrapped = parent.value;
+                    const wrapped = new WrappedSpan(innerSpan, sink, parentWrapped.liveTraceId, parentWrapped.liveScope);
+
+                    // IMPORTANT: options.attributes (e.g. "ui.step") are applied by Effect
+                    // AFTER tracer.span() returns. innerSpan.attributes is empty at this point.
+                    // We must include options.attributes directly.
+                    sink.emit({
+                        _tag: "SpanStart",
+                        traceId: parentWrapped.liveTraceId,
+                        spanId: innerSpan.spanId,
+                        parentSpanId: parentWrapped.spanId,
+                        name,
+                        attributes: { ...Object.fromEntries(innerSpan.attributes), ...options?.attributes },
+                        timestamp: Date.now(),
+                    });
+
+                    return wrapped;
+                }
+
+                // Not in a traced scope — pass through unchanged
+                return innerSpan;
+            },
+
+            context<X>(f: () => X, fiber: any): X {
+                // Delegate context propagation to the base tracer.
+                // This preserves OTel's OtelApi.context.with() behavior for
+                // W3C traceparent header propagation.
+                return baseTracer.context(f, fiber);
+            },
+        });
+
+        return Layer.setTracer(wrappedTracer);
+    }),
+);
+
+function createRootWrappedSpan(innerSpan: Span, sink: TraceSinkHandle, attributes: Record<string, unknown>): WrappedSpan {
+    const traceId = attributes[LIVE_TRACE_ID] as string;
+    const scope: TraceScope = {
+        type: (attributes[LIVE_TRACE_SCOPE_TYPE] as TraceScope["type"]) ?? "user",
+        id: (attributes[LIVE_TRACE_SCOPE_ID] as string) ?? "unknown",
+    };
+
+    // Emit TraceStart
+    sink.emit({
+        _tag: "TraceStart",
+        traceId,
+        label: (attributes["live-trace.label"] as string) ?? innerSpan.name,
+        scope,
+        timestamp: Date.now(),
+    });
+
+    // Emit SpanStart for the root span itself
+    // Include attributes from the options — Effect applies them AFTER tracer.span() returns
+    sink.emit({
+        _tag: "SpanStart",
+        traceId,
+        spanId: innerSpan.spanId,
+        name: innerSpan.name,
+        attributes: { ...Object.fromEntries(innerSpan.attributes), ...attributes },
+        timestamp: Date.now(),
+    });
+
+    const wrapped = new WrappedSpan(innerSpan, sink, traceId, scope);
+
+    // Override end to also emit TraceEnd after SpanEnd
+    const originalEnd = wrapped.end.bind(wrapped);
+    wrapped.end = (endTime: bigint, exit: any) => {
+        originalEnd(endTime, exit);
+
+        const startTime = innerSpan.status._tag === "Ended" ? innerSpan.status.startTime : BigInt(0);
+        const durationMs = Number(endTime - startTime) / 1_000_000;
+
+        sink.emit({
+            _tag: "TraceEnd",
+            traceId,
+            status: exit._tag === "Success" ? "completed" : "failed",
+            durationMs,
+            error: exit._tag === "Failure" ? String(exit.cause) : undefined,
+            timestamp: Date.now(),
+        });
+    };
+
+    return wrapped;
+}

package/src/WrappedSpan.ts

@@ -0,0 +1,138 @@
+/**
+ * WrappedSpan — Span decorator that intercepts lifecycle events.
+ *
+ * Implements the full Tracer.Span interface by delegating to an inner span
+ * (OTel or native) while emitting TraceEvents to a TraceSink.
+ *
+ * Detection: Use `isWrappedSpan(span)` to check if a span is wrapped.
+ * The Symbol brand avoids instanceof checks across package boundaries.
+ */
+import type { Context } from "effect/Context";
+import type { Exit } from "effect/Exit";
+import type { Option } from "effect/Option";
+import type { AnySpan, Span, SpanKind, SpanLink, SpanStatus } from "effect/Tracer";
+
+import type { TraceSinkHandle } from "./Sink.js";
+import type { TraceScope } from "./types.js";
+
+import { TRACE_INTERNAL } from "./types.js";
+
+export const LiveTraceSymbol: unique symbol = Symbol.for("@live-traces/WrappedSpan");
+
+export class WrappedSpan implements Span {
+    readonly _tag = "Span" as const;
+    readonly [LiveTraceSymbol] = true;
+
+    /** The logical trace ID for routing (e.g., "doc:abc123") */
+    readonly liveTraceId: string;
+
+    /** Scope for stream routing */
+    readonly liveScope: TraceScope;
+
+    constructor(
+        readonly inner: Span,
+        readonly sink: TraceSinkHandle,
+        liveTraceId: string,
+        liveScope: TraceScope,
+    ) {
+        this.liveTraceId = liveTraceId;
+        this.liveScope = liveScope;
+    }
+
+    // -- Delegated reads --
+
+    get name(): string {
+        return this.inner.name;
+    }
+    get spanId(): string {
+        return this.inner.spanId;
+    }
+    get traceId(): string {
+        return this.inner.traceId;
+    }
+    get parent(): Option<AnySpan> {
+        return this.inner.parent;
+    }
+    get context(): Context<never> {
+        return this.inner.context;
+    }
+    get status(): SpanStatus {
+        return this.inner.status;
+    }
+    get attributes(): ReadonlyMap<string, unknown> {
+        return this.inner.attributes;
+    }
+    get links(): ReadonlyArray<SpanLink> {
+        return this.inner.links;
+    }
+    get sampled(): boolean {
+        return this.inner.sampled;
+    }
+    get kind(): SpanKind {
+        return this.inner.kind;
+    }
+
+    // -- Intercepted mutations --
+
+    attribute(key: string, value: unknown): void {
+        this.inner.attribute(key, value);
+    }
+
+    event(name: string, startTime: bigint, attributes?: Record<string, unknown>): void {
+        this.inner.event(name, startTime, attributes);
+
+        // Emit as SpanEvent to sink
+        const level = attributes?.["effect.logLevel"] as string | undefined;
+        this.sink.emit({
+            _tag: "SpanEvent",
+            traceId: this.liveTraceId,
+            spanId: this.spanId,
+            name,
+            level: normalizeLevel(level),
+            attributes,
+            timestamp: Date.now(),
+        });
+    }
+
+    end(endTime: bigint, exit: Exit<unknown, unknown>): void {
+        this.inner.end(endTime, exit);
+
+        const startTime = this.inner.status._tag === "Ended" ? this.inner.status.startTime : BigInt(0);
+        const durationMs = Number(endTime - startTime) / 1_000_000;
+        const status = exit._tag === "Success" ? ("ok" as const) : ("error" as const);
+
+        this.sink.emit({
+            _tag: "SpanEnd",
+            traceId: this.liveTraceId,
+            spanId: this.spanId,
+            status,
+            durationMs,
+            timestamp: Date.now(),
+        });
+    }
+
+    addLinks(links: ReadonlyArray<SpanLink>): void {
+        this.inner.addLinks(links);
+    }
+}
+
+export const isWrappedSpan = (span: AnySpan): span is WrappedSpan => LiveTraceSymbol in span;
+
+export const shouldExclude = (attributes?: Record<string, unknown>): boolean => attributes?.[TRACE_INTERNAL] === true;
+
+function normalizeLevel(level: string | undefined): "Debug" | "Info" | "Warning" | "Error" | undefined {
+    if (!level) return undefined;
+    switch (level) {
+        case "DEBUG":
+            return "Debug";
+        case "INFO":
+            return "Info";
+        case "WARNING":
+        case "WARN":
+            return "Warning";
+        case "ERROR":
+            return "Error";
+        default:
+            return undefined;
+    }
+}

package/src/__tests__/tracer.test.ts

@@ -0,0 +1,238 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { describe, expect, it } from "vitest";
+
+import type { TraceEvent } from "../types.js";
+
+import { withTrace, step } from "../LiveTrace.js";
+import { TraceSinkLive, TraceTransportTag } from "../Sink.js";
+import { LiveTraceLayer } from "../Tracer.js";
+
+/**
+ * Creates a test transport that collects events in an array.
+ * Returns the layer and a reference to the collected events.
+ */
+function makeTestTransport() {
+    const events: TraceEvent[] = [];
+    const transport = {
+        send: (batch: ReadonlyArray<TraceEvent>) =>
+            Effect.sync(() => {
+                events.push(...batch);
+            }),
+    };
+    const layer = Layer.succeed(TraceTransportTag, transport);
+    return { events, layer };
+}
+
+/**
+ * Helper: build the full test layer (TraceSink + LiveTraceLayer)
+ * with a zero-interval flush for deterministic tests.
+ */
+function makeTestLayer(transportLayer: Layer.Layer<TraceTransportTag>) {
+    const sinkLayer = TraceSinkLive({ flushIntervalMs: 10 }).pipe(Layer.provide(transportLayer));
+    const traceLayer = LiveTraceLayer.pipe(Layer.provide(sinkLayer));
+    return Layer.merge(sinkLayer, traceLayer);
+}
+
+describe("LiveTraceLayer", () => {
+    it("captures TraceStart, SpanStart, SpanEnd, TraceEnd for a traced scope", async () => {
+        const { events, layer: transportLayer } = makeTestTransport();
+        const testLayer = makeTestLayer(transportLayer);
+
+        const program = withTrace({
+            traceId: "test:123",
+            label: "Test Workflow",
+            scope: { type: "team", id: "team-1" },
+        })(Effect.void);
+
+        await Effect.runPromise(
+            program.pipe(
+                Effect.provide(testLayer),
+                Effect.scoped,
+                // Give flush daemon time to fire
+                Effect.tap(() => Effect.sleep("50 millis")),
+            ),
+        );
+
+        const tags = events.map((e) => e._tag);
+        expect(tags).toContain("TraceStart");
+        expect(tags).toContain("SpanStart");
+        expect(tags).toContain("SpanEnd");
+        expect(tags).toContain("TraceEnd");
+
+        // Verify TraceStart has correct metadata
+        const traceStart = events.find((e) => e._tag === "TraceStart");
+        expect(traceStart).toMatchObject({
+            _tag: "TraceStart",
+            traceId: "test:123",
+            label: "Test Workflow",
+            scope: { type: "team", id: "team-1" },
+        });
+
+        // Verify TraceEnd
+        const traceEnd = events.find((e) => e._tag === "TraceEnd");
+        expect(traceEnd).toMatchObject({
+            _tag: "TraceEnd",
+            traceId: "test:123",
+            status: "completed",
+        });
+    });
+
+    it("captures nested child spans with parent-child relationships", async () => {
+        const { events, layer: transportLayer } = makeTestTransport();
+        const testLayer = makeTestLayer(transportLayer);
+
+        const program = withTrace({
+            traceId: "test:nested",
+            label: "Nested Test",
+            scope: { type: "team", id: "team-1" },
+        })(
+            Effect.gen(function* () {
+                yield* Effect.withSpan(Effect.void, "child-1");
+                yield* Effect.withSpan(Effect.void, "child-2");
+            }),
+        );
+
+        await Effect.runPromise(
+            program.pipe(
+                Effect.provide(testLayer),
+                Effect.scoped,
+                Effect.tap(() => Effect.sleep("50 millis")),
+            ),
+        );
+
+        const spanStarts = events.filter((e) => e._tag === "SpanStart");
+        const spanEnds = events.filter((e) => e._tag === "SpanEnd");
+
+        // Root span + 2 children = 3 SpanStarts
+        expect(spanStarts.length).toBe(3);
+        expect(spanEnds.length).toBe(3);
+
+        // Children should reference root's spanId as parentSpanId
+        const rootSpan = spanStarts.find((e) => e._tag === "SpanStart" && e.name === "Nested Test");
+        const child1 = spanStarts.find((e) => e._tag === "SpanStart" && e.name === "child-1");
+        const child2 = spanStarts.find((e) => e._tag === "SpanStart" && e.name === "child-2");
+
+        expect(rootSpan).toBeDefined();
+        expect(child1).toBeDefined();
+        expect(child2).toBeDefined();
+
+        if (child1?._tag === "SpanStart" && rootSpan?._tag === "SpanStart") {
+            expect(child1.parentSpanId).toBe(rootSpan.spanId);
+        }
+        if (child2?._tag === "SpanStart" && rootSpan?._tag === "SpanStart") {
+            expect(child2.parentSpanId).toBe(rootSpan.spanId);
+        }
+    });
+
+    it("captures Effect.log calls as SpanEvents via built-in tracerLogger", async () => {
+        const { events, layer: transportLayer } = makeTestTransport();
+        const testLayer = makeTestLayer(transportLayer);
+
+        const program = withTrace({
+            traceId: "test:logs",
+            label: "Log Test",
+            scope: { type: "team", id: "team-1" },
+        })(
+            Effect.gen(function* () {
+                yield* Effect.logInfo("Hello from traced scope");
+                yield* Effect.logWarning("A warning");
+            }),
+        );
+
+        await Effect.runPromise(
+            program.pipe(
+                Effect.provide(testLayer),
+                Effect.scoped,
+                Effect.tap(() => Effect.sleep("50 millis")),
+            ),
+        );
+
+        const spanEvents = events.filter((e) => e._tag === "SpanEvent");
+        expect(spanEvents.length).toBeGreaterThanOrEqual(2);
+
+        const infoEvent = spanEvents.find((e) => e._tag === "SpanEvent" && e.name.includes("Hello from traced scope"));
+        expect(infoEvent).toBeDefined();
+    });
+
+    it("does not capture spans outside a traced scope", async () => {
+        const { events, layer: transportLayer } = makeTestTransport();
+        const testLayer = makeTestLayer(transportLayer);
+
+        const program = Effect.withSpan(Effect.void, "outside-span");
+
+        await Effect.runPromise(
+            program.pipe(
+                Effect.provide(testLayer),
+                Effect.scoped,
+                Effect.tap(() => Effect.sleep("50 millis")),
+            ),
+        );
+
+        // No trace events should be emitted
+        expect(events.length).toBe(0);
+    });
+
+    it("LiveTrace.step creates ui.step attributed spans", async () => {
+        const { events, layer: transportLayer } = makeTestTransport();
+        const testLayer = makeTestLayer(transportLayer);
+
+        const program = withTrace({
+            traceId: "test:steps",
+            label: "Step Test",
+            scope: { type: "team", id: "team-1" },
+        })(
+            Effect.gen(function* () {
+                yield* step("Parsing")(Effect.void);
+                yield* step("Embedding")(Effect.void);
+            }),
+        );
+
+        await Effect.runPromise(
+            program.pipe(
+                Effect.provide(testLayer),
+                Effect.scoped,
+                Effect.tap(() => Effect.sleep("50 millis")),
+            ),
+        );
+
+        const spanStarts = events.filter((e) => e._tag === "SpanStart");
+        const parsingSpan = spanStarts.find((e) => e._tag === "SpanStart" && e.name === "Parsing");
+        const embeddingSpan = spanStarts.find((e) => e._tag === "SpanStart" && e.name === "Embedding");
+
+        expect(parsingSpan).toBeDefined();
+        expect(embeddingSpan).toBeDefined();
+    });
+
+    it("handles failed traces correctly", async () => {
+        const { events, layer: transportLayer } = makeTestTransport();
+        const testLayer = makeTestLayer(transportLayer);
+
+        const program = withTrace({
+            traceId: "test:fail",
+            label: "Fail Test",
+            scope: { type: "team", id: "team-1" },
+        })(Effect.fail("boom"));
+
+        await Effect.runPromise(
+            program.pipe(
+                Effect.provide(testLayer),
+                Effect.scoped,
+                Effect.tap(() => Effect.sleep("50 millis")),
+                Effect.catchAll(() => Effect.void),
+            ),
+        );
+
+        const traceEnd = events.find((e) => e._tag === "TraceEnd");
+        expect(traceEnd).toMatchObject({
+            _tag: "TraceEnd",
+            traceId: "test:fail",
+            status: "failed",
+        });
+
+        const spanEnd = events.find((e) => e._tag === "SpanEnd");
+        expect(spanEnd).toMatchObject({
+            status: "error",
+        });
+    });
+});

package/src/transports/sse.ts

@@ -0,0 +1,127 @@
+/**
+ * SSE TraceTransport - Server-Sent Events transport.
+ *
+ * Pushes batched trace events into an in-process broker. The broker fans
+ * batches out to any number of subscribers (HTTP connections holding an
+ * `EventSource`). Stream routing is per-`TraceScope` - a subscriber gets
+ * only events for the scope it subscribed to.
+ *
+ * ```ts
+ * import { Layer } from "effect";
+ * import {
+ *   LiveTraceLayer, TraceSinkLive,
+ *   SSETransportLayer, getSseBroker,
+ * } from "live-traces";
+ *
+ * // Server layer
+ * const TraceLive = LiveTraceLayer.pipe(
+ *   Layer.provide(TraceSinkLive({ flushIntervalMs: 100 })),
+ *   Layer.provide(SSETransportLayer),
+ * );
+ *
+ * // HTTP handler
+ * app.get("/traces/:scopeType/:scopeId", (req, res) => {
+ *   res.setHeader("Content-Type", "text/event-stream");
+ *   const unsubscribe = getSseBroker().subscribe(
+ *     { type: req.params.scopeType, id: req.params.scopeId },
+ *     (events) => res.write(`data: ${JSON.stringify(events)}\n\n`),
+ *   );
+ *   req.on("close", unsubscribe);
+ * });
+ * ```
+ */
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import type { TraceEvent, TraceScope } from "../types.js";
+
+import { TraceTransportTag, type TraceTransport } from "../Sink.js";
+
+type Subscriber = (events: ReadonlyArray<TraceEvent>) => void;
+
+/**
+ * In-process pub/sub broker. Routes trace events to subscribers keyed by
+ * `scope.type/scope.id`. A subscriber for `team/abc` receives only events
+ * for that team's traces.
+ */
+export class SseBroker {
+    private readonly subscribers = new Map<string, Set<Subscriber>>();
+    private readonly scopeByTraceId = new Map<string, TraceScope>();
+
+    private key(scope: TraceScope): string {
+        return `${scope.type}/${scope.id}`;
+    }
+
+    /** Subscribe to events for a specific scope. Returns an unsubscribe fn. */
+    subscribe(scope: TraceScope, listener: Subscriber): () => void {
+        const k = this.key(scope);
+        let set = this.subscribers.get(k);
+        if (!set) {
+            set = new Set();
+            this.subscribers.set(k, set);
+        }
+        set.add(listener);
+        return () => {
+            const s = this.subscribers.get(k);
+            if (!s) return;
+            s.delete(listener);
+            if (s.size === 0) this.subscribers.delete(k);
+        };
+    }
+
+    /** Publish a batch - fan out per scope. Called by the transport. */
+    publish(events: ReadonlyArray<TraceEvent>): void {
+        for (const e of events) {
+            if (e._tag === "TraceStart") this.scopeByTraceId.set(e.traceId, e.scope);
+        }
+
+        const grouped = new Map<string, TraceEvent[]>();
+        for (const e of events) {
+            const scope = this.scopeByTraceId.get(e.traceId);
+            if (!scope) continue;
+            const k = this.key(scope);
+            const arr = grouped.get(k) ?? [];
+            arr.push(e);
+            grouped.set(k, arr);
+        }
+
+        for (const [k, batch] of grouped) {
+            const set = this.subscribers.get(k);
+            if (!set) continue;
+            for (const listener of set) {
+                try {
+                    listener(batch);
+                } catch {
+                    // Subscriber threw - keep the broker healthy.
+                }
+            }
+        }
+
+        for (const e of events) {
+            if (e._tag === "TraceEnd") this.scopeByTraceId.delete(e.traceId);
+        }
+    }
+
+    /** Active subscriber count for a scope (useful for tests / metrics). */
+    subscriberCount(scope: TraceScope): number {
+        return this.subscribers.get(this.key(scope))?.size ?? 0;
+    }
+}
+
+let _broker: SseBroker | null = null;
+
+/** Singleton broker. Same instance is used by transport + HTTP handlers. */
+export function getSseBroker(): SseBroker {
+    if (!_broker) _broker = new SseBroker();
+    return _broker;
+}
+
+const sseTransport: TraceTransport = {
+    send: (events) =>
+        Effect.sync(() => {
+            getSseBroker().publish(events);
+        }),
+};
+
+/** Effect Layer wiring the SSE transport into the trace sink. */
+export const SSETransportLayer: Layer.Layer<TraceTransportTag> = Layer.succeed(TraceTransportTag, sseTransport);