effect-start 0.26.0 → 0.28.0

package/src/console/Console.ts

@@ -1,42 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as Route from "../Route.ts"
-import * as RouteTree from "../RouteTree.ts"
-import * as ConsoleErrors from "./ConsoleErrors.ts"
-import * as ConsoleLogger from "./ConsoleLogger.ts"
-import * as ConsoleMetrics from "./ConsoleMetrics.ts"
-import * as ConsoleProcess from "./ConsoleProcess.ts"
-import * as ConsoleStore from "./ConsoleStore.ts"
-import * as ConsoleTracer from "./ConsoleTracer.ts"
-import consoleRoutes from "./routes/tree.ts"
-
-export { ConsoleStore } from "./ConsoleStore.ts"
-
-export function layer(
-  options?: ConsoleStore.ConsoleStoreOptions,
-): Layer.Layer<ConsoleStore.ConsoleStore> {
-  const store = ConsoleStore.layer(options)
-  return Layer.mergeAll(
-    ConsoleTracer.layer,
-    ConsoleLogger.layer,
-    ConsoleMetrics.layer,
-    ConsoleErrors.layer,
-    ConsoleProcess.layer,
-  ).pipe(Layer.provideMerge(store))
-}
-
-export function routeLayer(
-  prefix: string,
-): Layer.Layer<Route.Routes, never, Route.Routes | ConsoleStore.ConsoleStore> {
-  return Layer.effect(
-    Route.Routes,
-    Effect.gen(function* () {
-      const existing = yield* Route.Routes
-      ConsoleStore.store.prefix = prefix
-      const tree = Route.tree({
-        [prefix as "/"]: consoleRoutes,
-      })
-      return RouteTree.merge(existing, tree)
-    }),
-  )
-}

package/src/console/ConsoleLogger.ts

@@ -1,56 +0,0 @@
-import * as Cause from "effect/Cause"
-import * as Effect from "effect/Effect"
-import * as FiberId from "effect/FiberId"
-import * as FiberRef from "effect/FiberRef"
-import * as HashMap from "effect/HashMap"
-import * as HashSet from "effect/HashSet"
-import * as Layer from "effect/Layer"
-import * as List from "effect/List"
-import * as Logger from "effect/Logger"
-import * as PubSub from "effect/PubSub"
-import * as ConsoleStore from "./ConsoleStore.ts"
-
-let logId = 0
-
-export const layer: Layer.Layer<never, never, ConsoleStore.ConsoleStore> = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const store = yield* ConsoleStore.ConsoleStore
-
-    const logger = Logger.make(
-      ({ message, logLevel, cause, fiberId, spans, annotations, date }) => {
-        const levelMap: Record<string, ConsoleStore.ConsoleLog["level"]> = {
-          Debug: "DEBUG",
-          Info: "INFO",
-          Warning: "WARNING",
-          Error: "ERROR",
-          Fatal: "FATAL",
-        }
-        const level = levelMap[logLevel._tag] ?? "INFO"
-        const causeStr = !Cause.isEmpty(cause)
-          ? Cause.pretty(cause, { renderErrorCause: true })
-          : undefined
-        const spanNames: Array<string> = []
-        List.forEach(spans, (s) => spanNames.push(s.label))
-        const ann: Record<string, unknown> = {}
-        HashMap.forEach(annotations, (v, k) => {
-          ann[k] = v
-        })
-
-        const log: ConsoleStore.ConsoleLog = {
-          id: String(++logId),
-          date,
-          level,
-          message: String(message),
-          fiberId: FiberId.threadName(fiberId),
-          cause: causeStr,
-          spans: spanNames,
-          annotations: ann,
-        }
-        store.logs.push(log)
-        Effect.runSync(PubSub.publish(store.events, { _tag: "Log", log }))
-      },
-    )
-
-    yield* FiberRef.update(FiberRef.currentLoggers, (loggers) => HashSet.add(loggers, logger))
-  }),
-)

package/src/console/ConsoleStore.ts

@@ -1,187 +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: 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

@@ -1,107 +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.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))
-  }),
-)

package/src/console/index.ts

@@ -1,3 +0,0 @@
-export * as Console from "./Console.ts"
-export * as ConsoleStore from "./ConsoleStore.ts"
-export * as Simulation from "./Simulation.ts"

package/src/console/routes/fibers/route.tsx

@@ -1,45 +0,0 @@
-import * as Stream from "effect/Stream"
-import * as Route from "../../../Route.ts"
-import * as HyperHtml from "../../../hyper/HyperHtml.ts"
-import * as HyperRoute from "../../../hyper/HyperRoute.ts"
-import * as ConsoleStore from "../../ConsoleStore.ts"
-import * as Fibers from "../../ui/Fibers.tsx"
-import * as Shell from "../../ui/Shell.tsx"
-
-export default Route.get(
-  HyperRoute.html(function* () {
-    const fibers = Fibers.collectFibers(
-      ConsoleStore.store.logs.toArray(),
-      ConsoleStore.store.spans.toArray(),
-    )
-    return (
-      <Shell.Shell prefix={ConsoleStore.store.prefix} active="fibers">
-        <div style="display:flex;flex-direction:column;flex:1;overflow:hidden">
-          <div class="tab-header">Fibers</div>
-          <div id="fibers-container" class="tab-body">
-            <Fibers.FiberList fibers={fibers} prefix={ConsoleStore.store.prefix} />
-          </div>
-          <div data-init={`@get('${ConsoleStore.store.prefix}/fibers')`} />
-        </div>
-      </Shell.Shell>
-    )
-  }),
-  Route.sse(
-    Stream.fromPubSub(ConsoleStore.store.events).pipe(
-      Stream.filter((e) => e._tag === "SpanStart" || e._tag === "SpanEnd" || e._tag === "Log"),
-      Stream.map(() => {
-        const fibers = Fibers.collectFibers(
-          ConsoleStore.store.logs.toArray(),
-          ConsoleStore.store.spans.toArray(),
-        )
-        const html = HyperHtml.renderToString(
-          <Fibers.FiberList fibers={fibers} prefix={ConsoleStore.store.prefix} />,
-        ).replace(/\n/g, "")
-        return {
-          event: "datastar-patch-elements",
-          data: `selector #fibers-container\nmode inner\nelements ${html}`,
-        }
-      }),
-    ),
-  ),
-)

package/src/console/routes/git/route.tsx

@@ -1,64 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Schedule from "effect/Schedule"
-import * as Stream from "effect/Stream"
-import * as ChildProcess from "../../../ChildProcess.ts"
-import * as Route from "../../../Route.ts"
-import * as HyperHtml from "../../../hyper/HyperHtml.ts"
-import * as HyperRoute from "../../../hyper/HyperRoute.ts"
-import * as ConsoleStore from "../../ConsoleStore.ts"
-import * as Git from "../../ui/Git.tsx"
-import * as Shell from "../../ui/Shell.tsx"
-
-const exec = (args: Array<string>, cwd?: string) =>
-  Effect.gen(function* () {
-    const handle = yield* ChildProcess.make("git", args, cwd ? { cwd } : undefined)
-    return yield* handle.stdout.pipe(Stream.decodeText("utf-8"), Stream.mkString)
-  }).pipe(Effect.catchAll(() => Effect.succeed("")))
-
-const gitStatus = exec(["rev-parse", "--show-toplevel"]).pipe(
-  Effect.flatMap((root) => {
-    const cwd = root.trim()
-    return Effect.all(
-      {
-        porcelain: exec(["status", "--porcelain=v2", "--branch"], cwd),
-        tag: exec(["describe", "--tags", "--abbrev=0"], cwd),
-        tagDistance: exec(["rev-list", "--count", "HEAD", "--not", "--tags"], cwd),
-      },
-      { concurrency: "unbounded" },
-    )
-  }),
-  Effect.map(({ porcelain, tag, tagDistance }) =>
-    Git.parseGitStatus(porcelain, `${tag.trim()}\n${tagDistance.trim()}`),
-  ),
-)
-
-export default Route.get(
-  HyperRoute.html(function* () {
-    const status = yield* gitStatus
-    return (
-      <Shell.Shell prefix={ConsoleStore.store.prefix} active="git">
-        <div class="tab-header">Git</div>
-        <div id="git-container" class="tab-body">
-          <Git.GitStatusView status={status} />
-        </div>
-        <div data-init={`@get('${ConsoleStore.store.prefix}/git')`} />
-      </Shell.Shell>
-    )
-  }),
-  Route.sse(
-    Stream.repeatEffect(
-      gitStatus.pipe(
-        Effect.map((status) => {
-          const html = HyperHtml.renderToString(<Git.GitStatusView status={status} />).replace(
-            /\n/g,
-            "",
-          )
-          return {
-            event: "datastar-patch-elements" as const,
-            data: `selector #git-container\nmode inner\nelements ${html}`,
-          }
-        }),
-      ),
-    ).pipe(Stream.schedule(Schedule.spaced("2 seconds"))),
-  ),
-)

package/src/console/routes/route.tsx

@@ -1,8 +0,0 @@
-import * as Route from "../../Route.ts"
-import * as ConsoleStore from "../ConsoleStore.ts"
-
-export default Route.get(
-  Route.render(function* () {
-    return Route.redirect(`${ConsoleStore.store.prefix}/traces`)
-  }),
-)

package/src/console/routes/traceDetail.tsx

@@ -1,22 +0,0 @@
-import * as Schema from "effect/Schema"
-import * as Route from "../../Route.ts"
-import * as RouteSchema from "../../RouteSchema.ts"
-import * as HyperRoute from "../../hyper/HyperRoute.ts"
-import * as ConsoleStore from "../ConsoleStore.ts"
-import * as Shell from "../ui/Shell.tsx"
-import * as Traces from "../ui/Traces.tsx"
-
-export default Route.get(
-  RouteSchema.schemaPathParams(Schema.Struct({ id: Schema.String })),
-  HyperRoute.html(function* (ctx) {
-    const allSpans = ConsoleStore.store.spans.toArray()
-    const groups = Traces.groupByTraceId(allSpans)
-    const spans = groups.get(ctx.pathParams.id) ?? []
-
-    return (
-      <Shell.Shell prefix={ConsoleStore.store.prefix} active="traces">
-        <Traces.TraceDetail prefix={ConsoleStore.store.prefix} spans={spans} />
-      </Shell.Shell>
-    )
-  }),
-)