effect-start 0.22.0 → 0.23.0

package/dist/console/ConsoleTracer.d.ts

@@ -0,0 +1,3 @@
+import * as Layer from "effect/Layer";
+import * as ConsoleStore from "./ConsoleStore.ts";
+export declare const layer: Layer.Layer<never, never, ConsoleStore.ConsoleStore>;

package/dist/console/ConsoleTracer.js

@@ -0,0 +1,94 @@
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as FiberId from "effect/FiberId";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as PubSub from "effect/PubSub";
+import * as Tracer from "effect/Tracer";
+import * as ConsoleStore from "./ConsoleStore.js";
+const publish = (store, event) => Effect.runSync(PubSub.publish(store.events, event));
+const make = (store) => Tracer.make({
+    span(name, parent, context, links, startTime, kind, options) {
+        const parentSpanId = Option.isSome(parent) && parent.value._tag === "Span" ? parent.value.spanId : undefined;
+        const traceId = Option.isSome(parent)
+            ? parent.value.traceId
+            : Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
+        const spanId = Math.random().toString(36).slice(2);
+        const attributes = {};
+        const currentFiber = Fiber.getCurrentFiber();
+        if (Option.isSome(currentFiber)) {
+            attributes["fiber.id"] = FiberId.threadName(currentFiber.value.id());
+        }
+        if (typeof options?.captureStackTrace === "function") {
+            const stacktrace = options.captureStackTrace();
+            if (stacktrace) {
+                attributes["code.stacktrace"] = stacktrace;
+            }
+        }
+        const consoleSpan = {
+            spanId,
+            traceId,
+            name,
+            kind,
+            parentSpanId,
+            startTime,
+            endTime: undefined,
+            durationMs: undefined,
+            status: "started",
+            attributes,
+            events: [],
+        };
+        store.spans.push(consoleSpan);
+        publish(store, { _tag: "SpanStart", span: consoleSpan });
+        const attrs = new Map(Object.entries(attributes));
+        const spanLinks = [...links];
+        const span = {
+            _tag: "Span",
+            name,
+            spanId,
+            traceId,
+            parent,
+            context,
+            get status() {
+                if (consoleSpan.endTime != null) {
+                    return {
+                        _tag: "Ended",
+                        startTime: consoleSpan.startTime,
+                        endTime: consoleSpan.endTime,
+                        exit: Exit.void,
+                    };
+                }
+                return { _tag: "Started", startTime: consoleSpan.startTime };
+            },
+            attributes: attrs,
+            links: spanLinks,
+            sampled: true,
+            kind,
+            end(endTime, exit) {
+                consoleSpan.endTime = endTime;
+                consoleSpan.durationMs = Number(endTime - consoleSpan.startTime) / 1_000_000;
+                consoleSpan.status = Exit.isSuccess(exit) ? "ok" : "error";
+                publish(store, { _tag: "SpanEnd", span: consoleSpan });
+            },
+            attribute(key, value) {
+                attrs.set(key, value);
+                consoleSpan.attributes[key] = value;
+            },
+            event(name, startTime, attributes) {
+                consoleSpan.events.push({ name, startTime, attributes });
+            },
+            addLinks(newLinks) {
+                spanLinks.push(...newLinks);
+            },
+        };
+        return span;
+    },
+    context(f) {
+        return f();
+    },
+});
+export const layer = Layer.unwrapEffect(Effect.gen(function* () {
+    const store = yield* ConsoleStore.ConsoleStore;
+    return Layer.setTracer(make(store));
+}));

package/dist/console/Simulation.d.ts

@@ -0,0 +1,2 @@
+import * as Layer from "effect/Layer";
+export declare const layer: Layer.Layer<never, never, never>;