effect-start 0.22.0 → 0.23.0

package/src/console/ConsoleProcess.ts

@@ -0,0 +1,59 @@
+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.ts"
+
+function snapshot(): ConsoleStore.ProcessStats {
+  const mem = process.memoryUsage()
+  const cpu = process.cpuUsage()
+  const res = process.resourceUsage()
+  const loadavg = NOS.loadavg() as [number, number, number]
+  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.Layer<never, never, ConsoleStore.ConsoleStore> = 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/src/console/ConsoleStore.ts

@@ -0,0 +1,187 @@
+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: ConsoleStoreShape = GlobalValue.globalValue(
+  Symbol.for("effect-start/ConsoleStore"),
+  () => ({
+    prefix: "/console",
+    spans: new CircularBuffer<ConsoleSpan>(1000),
+    logs: new CircularBuffer<ConsoleLog>(5000),
+    errors: new CircularBuffer<ConsoleError>(1000),
+    metrics: [] as Array<ConsoleMetricSnapshot>,
+    process: undefined as ProcessStats | undefined,
+    events: Effect.runSync(PubSub.unbounded<ConsoleEvent>()),
+    fiberParents: new Map<string, string>(),
+    fiberContexts: new Map<string, FiberContext>(),
+  }),
+)
+
+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 class CircularBuffer<T> {
+  private buffer: Array<T | undefined>
+  private head = 0
+  private count = 0
+  capacity: number
+
+  constructor(capacity: number) {
+    this.capacity = capacity
+    this.buffer = Array.from({ length: capacity })
+  }
+
+  push(item: T): void {
+    this.buffer[this.head] = item
+    this.head = (this.head + 1) % this.capacity
+    if (this.count < this.capacity) this.count++
+  }
+
+  toArray(): Array<T> {
+    if (this.count === 0) return []
+    const result: Array<T> = []
+    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(): number {
+    return this.count
+  }
+}
+
+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 function fiberIdCounter(): number {
+  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")<
+  ConsoleStore,
+  ConsoleStoreShape
+>() {}
+
+export interface ConsoleStoreOptions {
+  readonly spanCapacity?: number
+  readonly logCapacity?: number
+  readonly errorCapacity?: number
+}
+
+export function layer(options?: ConsoleStoreOptions): Layer.Layer<ConsoleStore> {
+  if (options?.spanCapacity)
+    (store as any).spans = new CircularBuffer<ConsoleSpan>(options.spanCapacity)
+  if (options?.logCapacity)
+    (store as any).logs = new CircularBuffer<ConsoleLog>(options.logCapacity)
+  if (options?.errorCapacity)
+    (store as any).errors = new CircularBuffer<ConsoleError>(options.errorCapacity)
+  return Layer.sync(ConsoleStore, () => store)
+}

package/src/console/ConsoleTracer.ts

@@ -0,0 +1,107 @@
+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.ts"
+
+const publish = (store: ConsoleStore.ConsoleStoreShape, event: ConsoleStore.ConsoleEvent) =>
+  Effect.runSync(PubSub.publish(store.events, event))
+
+const make = (store: ConsoleStore.ConsoleStoreShape): Tracer.Tracer =>
+  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: Record<string, unknown> = {}
+      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: ConsoleStore.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<string, unknown>(Object.entries(attributes))
+      const spanLinks = [...links]
+
+      const span: Tracer.Span = {
+        _tag: "Span",
+        name,
+        spanId,
+        traceId,
+        parent,
+        context,
+        get status(): Tracer.SpanStatus {
+          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 as Record<string, unknown>)[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.Layer<never, never, ConsoleStore.ConsoleStore> = Layer.unwrapEffect(
+  Effect.gen(function* () {
+    const store = yield* ConsoleStore.ConsoleStore
+    return Layer.setTracer(make(store))
+  }),
+)