effect-start 0.23.1 → 0.26.0

package/dist/console/ConsoleProcess.js

@@ -1,49 +0,0 @@
-import * as NOS from "node:os";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as PubSub from "effect/PubSub";
-import * as Schedule from "effect/Schedule";
-import * as ConsoleStore from "./ConsoleStore.js";
-function snapshot() {
-    const mem = process.memoryUsage();
-    const cpu = process.cpuUsage();
-    const res = process.resourceUsage();
-    const loadavg = NOS.loadavg();
-    return {
-        pid: process.pid,
-        uptime: process.uptime(),
-        memory: {
-            rss: mem.rss,
-            heapUsed: mem.heapUsed,
-            heapTotal: mem.heapTotal,
-            external: mem.external,
-            arrayBuffers: mem.arrayBuffers,
-        },
-        cpu: { user: cpu.user, system: cpu.system },
-        resourceUsage: {
-            maxRSS: res.maxRSS,
-            minorPageFault: res.minorPageFault,
-            majorPageFault: res.majorPageFault,
-            fsRead: res.fsRead,
-            fsWrite: res.fsWrite,
-            voluntaryContextSwitches: res.voluntaryContextSwitches,
-            involuntaryContextSwitches: res.involuntaryContextSwitches,
-        },
-        system: {
-            loadavg,
-            freemem: NOS.freemem(),
-            totalmem: NOS.totalmem(),
-            cpuCount: NOS.cpus().length,
-            platform: NOS.platform(),
-            arch: NOS.arch(),
-        },
-    };
-}
-export const layer = Layer.scopedDiscard(Effect.gen(function* () {
-    const store = yield* ConsoleStore.ConsoleStore;
-    yield* Effect.forkScoped(Effect.schedule(Effect.sync(() => {
-        const stats = snapshot();
-        store.process = stats;
-        Effect.runSync(PubSub.publish(store.events, { _tag: "ProcessSnapshot", stats }));
-    }), Schedule.spaced("2 seconds")));
-}));

package/dist/console/ConsoleStore.d.ts

@@ -1,144 +0,0 @@
-import * as Context from "effect/Context";
-import * as Layer from "effect/Layer";
-import * as PubSub from "effect/PubSub";
-export declare const store: ConsoleStoreShape;
-export interface ConsoleSpan {
-    readonly spanId: string;
-    readonly traceId: string;
-    readonly name: string;
-    readonly kind: string;
-    readonly parentSpanId: string | undefined;
-    startTime: bigint;
-    endTime: bigint | undefined;
-    durationMs: number | undefined;
-    status: "started" | "ok" | "error";
-    readonly attributes: Record<string, unknown>;
-    readonly events: Array<{
-        name: string;
-        startTime: bigint;
-        attributes?: Record<string, unknown>;
-    }>;
-}
-export interface ConsoleLog {
-    readonly id: string;
-    readonly date: Date;
-    readonly level: "DEBUG" | "INFO" | "WARNING" | "ERROR" | "FATAL";
-    readonly message: string;
-    readonly fiberId: string;
-    readonly cause: string | undefined;
-    readonly spans: Array<string>;
-    readonly annotations: Record<string, unknown>;
-}
-export interface ProcessStats {
-    readonly pid: number;
-    readonly uptime: number;
-    readonly memory: {
-        readonly rss: number;
-        readonly heapUsed: number;
-        readonly heapTotal: number;
-        readonly external: number;
-        readonly arrayBuffers: number;
-    };
-    readonly cpu: {
-        readonly user: number;
-        readonly system: number;
-    };
-    readonly resourceUsage: {
-        readonly maxRSS: number;
-        readonly minorPageFault: number;
-        readonly majorPageFault: number;
-        readonly fsRead: number;
-        readonly fsWrite: number;
-        readonly voluntaryContextSwitches: number;
-        readonly involuntaryContextSwitches: number;
-    };
-    readonly system: {
-        readonly loadavg: readonly [number, number, number];
-        readonly freemem: number;
-        readonly totalmem: number;
-        readonly cpuCount: number;
-        readonly platform: string;
-        readonly arch: string;
-    };
-}
-export interface ConsoleErrorDetail {
-    readonly kind: "fail" | "die";
-    readonly tag: string | undefined;
-    readonly message: string;
-    readonly properties: Record<string, unknown>;
-    readonly span: string | undefined;
-}
-export interface ConsoleError {
-    readonly id: string;
-    readonly date: Date;
-    readonly fiberId: string;
-    readonly interrupted: boolean;
-    readonly prettyPrint: string;
-    readonly details: Array<ConsoleErrorDetail>;
-}
-export interface ConsoleMetricSnapshot {
-    readonly name: string;
-    readonly type: "counter" | "gauge" | "histogram" | "summary" | "frequency";
-    readonly value: unknown;
-    readonly tags: ReadonlyArray<{
-        key: string;
-        value: string;
-    }>;
-    readonly timestamp: number;
-}
-export type ConsoleEvent = {
-    readonly _tag: "SpanStart";
-    readonly span: ConsoleSpan;
-} | {
-    readonly _tag: "SpanEnd";
-    readonly span: ConsoleSpan;
-} | {
-    readonly _tag: "Log";
-    readonly log: ConsoleLog;
-} | {
-    readonly _tag: "Error";
-    readonly error: ConsoleError;
-} | {
-    readonly _tag: "MetricsSnapshot";
-    readonly metrics: Array<ConsoleMetricSnapshot>;
-} | {
-    readonly _tag: "ProcessSnapshot";
-    readonly stats: ProcessStats;
-};
-export declare class CircularBuffer<T> {
-    private buffer;
-    private head;
-    private count;
-    capacity: number;
-    constructor(capacity: number);
-    push(item: T): void;
-    toArray(): Array<T>;
-    get size(): number;
-}
-export interface FiberContext {
-    readonly spanName: string | undefined;
-    readonly traceId: string | undefined;
-    readonly annotations: Record<string, unknown>;
-}
-export interface ConsoleStoreShape {
-    prefix: string;
-    readonly spans: CircularBuffer<ConsoleSpan>;
-    readonly logs: CircularBuffer<ConsoleLog>;
-    readonly errors: CircularBuffer<ConsoleError>;
-    metrics: Array<ConsoleMetricSnapshot>;
-    process: ProcessStats | undefined;
-    readonly events: PubSub.PubSub<ConsoleEvent>;
-    readonly fiberParents: Map<string, string>;
-    readonly fiberContexts: Map<string, FiberContext>;
-}
-export declare function fiberIdCounter(): number;
-declare const ConsoleStore_base: Context.TagClass<ConsoleStore, "effect-start/ConsoleStore", ConsoleStoreShape>;
-export declare class ConsoleStore extends ConsoleStore_base {
-}
-export interface ConsoleStoreOptions {
-    readonly spanCapacity?: number;
-    readonly logCapacity?: number;
-    readonly errorCapacity?: number;
-}
-export declare function layer(options?: ConsoleStoreOptions): Layer.Layer<ConsoleStore>;
-export {};

package/dist/console/ConsoleStore.js

@@ -1,61 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as GlobalValue from "effect/GlobalValue";
-import * as Layer from "effect/Layer";
-import * as MutableRef from "effect/MutableRef";
-import * as PubSub from "effect/PubSub";
-export const store = GlobalValue.globalValue(Symbol.for("effect-start/ConsoleStore"), () => ({
-    prefix: "/console",
-    spans: new CircularBuffer(1000),
-    logs: new CircularBuffer(5000),
-    errors: new CircularBuffer(1000),
-    metrics: [],
-    process: undefined,
-    events: Effect.runSync(PubSub.unbounded()),
-    fiberParents: new Map(),
-    fiberContexts: new Map(),
-}));
-export class CircularBuffer {
-    buffer;
-    head = 0;
-    count = 0;
-    capacity;
-    constructor(capacity) {
-        this.capacity = capacity;
-        this.buffer = Array.from({ length: capacity });
-    }
-    push(item) {
-        this.buffer[this.head] = item;
-        this.head = (this.head + 1) % this.capacity;
-        if (this.count < this.capacity)
-            this.count++;
-    }
-    toArray() {
-        if (this.count === 0)
-            return [];
-        const result = [];
-        const start = this.count < this.capacity ? 0 : this.head;
-        for (let i = 0; i < this.count; i++) {
-            result.push(this.buffer[(start + i) % this.capacity]);
-        }
-        return result;
-    }
-    get size() {
-        return this.count;
-    }
-}
-export function fiberIdCounter() {
-    const counter = GlobalValue.globalValue(Symbol.for("effect/Fiber/Id/_fiberCounter"), () => MutableRef.make(0));
-    return MutableRef.get(counter);
-}
-export class ConsoleStore extends Context.Tag("effect-start/ConsoleStore")() {
-}
-export function layer(options) {
-    if (options?.spanCapacity)
-        store.spans = new CircularBuffer(options.spanCapacity);
-    if (options?.logCapacity)
-        store.logs = new CircularBuffer(options.logCapacity);
-    if (options?.errorCapacity)
-        store.errors = new CircularBuffer(options.errorCapacity);
-    return Layer.sync(ConsoleStore, () => store);
-}

package/dist/console/ConsoleTracer.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

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