effect-start 0.27.0 → 0.28.0

package/src/tower/Tower.ts

@@ -0,0 +1,47 @@
+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 sqlBun from "effect-start/sql/bun"
+import type * as SqlClient from "../sql/SqlClient.ts"
+import * as TowerErrors from "./TowerErrors.ts"
+import * as TowerLogger from "./TowerLogger.ts"
+import * as TowerMetrics from "./TowerMetrics.ts"
+import * as TowerProcess from "./TowerProcess.ts"
+import * as TowerStore from "./TowerStore.ts"
+import * as TowerTracer from "./TowerTracer.ts"
+import consoleRoutes from "./routes/tree.ts"
+
+export function layer(
+  options?: TowerStore.TowerStoreOptions & {
+    readonly sqlLayer?: Layer.Layer<SqlClient.SqlClient, SqlClient.SqlError>
+  },
+): Layer.Layer<TowerStore.TowerStore> {
+  const sqlLayer =
+    options?.sqlLayer ?? sqlBun.layer({ adapter: "sqlite", filename: ":memory:" } as any)
+  const store = TowerStore.layer(options).pipe(Layer.provide(sqlLayer), Layer.orDie)
+  const features = Layer.mergeAll(
+    TowerTracer.layer,
+    TowerLogger.layer,
+    TowerMetrics.layer,
+    TowerErrors.layer,
+    TowerProcess.layer,
+  ).pipe(Layer.provide(store))
+  return Layer.merge(store, features)
+}
+
+export function layerRoutes(options?: { prefix?: string }) {
+  const prefix = options?.prefix ?? "/tower"
+
+  return Layer.effect(
+    Route.Routes,
+    Effect.gen(function* () {
+      const existing = yield* Route.Routes
+      TowerStore.store.prefix = prefix
+      const tree = Route.tree({
+        [prefix as "/"]: consoleRoutes,
+      })
+      return RouteTree.merge(existing, tree)
+    }),
+  )
+}

package/src/tower/TowerErrors.ts

@@ -0,0 +1,224 @@
+import * as Cause from "effect/Cause"
+import * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as FiberId from "effect/FiberId"
+import * as FiberRef from "effect/FiberRef"
+import * as HashMap from "effect/HashMap"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as PubSub from "effect/PubSub"
+import type * as Context from "effect/Context"
+import type * as Fiber from "effect/Fiber"
+import * as Supervisor from "effect/Supervisor"
+import * as TowerStore from "./TowerStore.ts"
+
+function safeSerialize(value: unknown, depth = 0): unknown {
+  if (depth > 4) return "<deep>"
+  if (value === null || value === undefined) return value
+  if (typeof value === "bigint") return `${value}n`
+  if (typeof value === "function") return undefined
+  if (typeof value === "symbol") return value.toString()
+  if (typeof value !== "object") return value
+  if (value instanceof Date) return value.toISOString()
+  if (value instanceof Error) return value.message
+  if (Array.isArray(value)) return value.slice(0, 20).map((v) => safeSerialize(v, depth + 1))
+  const proto = Object.getPrototypeOf(value)
+  if (proto !== null && proto !== Object.prototype) {
+    if (typeof (value as any)._tag === "string") {
+      return serializeTaggedObject(value as Record<string, unknown>, depth)
+    }
+    return `<${proto.constructor?.name ?? "object"}>`
+  }
+  return serializePlainObject(value as Record<string, unknown>, depth)
+}
+
+function serializePlainObject(
+  obj: Record<string, unknown>,
+  depth: number,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = {}
+  let count = 0
+  for (const [k, v] of Object.entries(obj)) {
+    if (count >= 20) break
+    if (typeof v === "function") continue
+    const serialized = safeSerialize(v, depth + 1)
+    if (serialized !== undefined) {
+      out[k] = serialized
+      count++
+    }
+  }
+  return out
+}
+
+function serializeTaggedObject(
+  obj: Record<string, unknown>,
+  depth: number,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = { _tag: obj._tag }
+  let count = 0
+  for (const [k, v] of Object.entries(obj)) {
+    if (count >= 20) break
+    if (k === "_tag") continue
+    if (typeof v === "function") continue
+    if (k === "stack" || k === "name") continue
+    const serialized = safeSerialize(v, depth + 1)
+    if (serialized !== undefined) {
+      out[k] = serialized
+      count++
+    }
+  }
+  return out
+}
+
+function extractTag(error: unknown): string | undefined {
+  if (
+    error !== null &&
+    typeof error === "object" &&
+    "_tag" in error &&
+    typeof (error as any)._tag === "string"
+  ) {
+    return (error as any)._tag
+  }
+  return undefined
+}
+
+function extractMessage(error: unknown): string {
+  if (error instanceof Error) return error.message
+  if (typeof error === "string") return error
+  const tag = extractTag(error)
+  if (tag) return tag
+  try {
+    return String(error)
+  } catch {
+    return "<unknown>"
+  }
+}
+
+function extractProperties(error: unknown): Record<string, unknown> {
+  if (error === null || error === undefined || typeof error !== "object") return {}
+  const out: Record<string, unknown> = {}
+  let count = 0
+  for (const [k, v] of Object.entries(error)) {
+    if (count >= 20) break
+    if (k === "_tag" || k === "stack" || k === "name") continue
+    if (typeof v === "function") continue
+    const serialized = safeSerialize(v, 0)
+    if (serialized !== undefined) {
+      out[k] = serialized
+      count++
+    }
+  }
+  return out
+}
+
+const spanSymbol = Symbol.for("effect/SpanAnnotation")
+
+function extractSpanName(error: unknown): string | undefined {
+  if (error !== null && typeof error === "object" && spanSymbol in error) {
+    const span = (error as any)[spanSymbol]
+    return typeof span?.name === "string" ? span.name : undefined
+  }
+  return undefined
+}
+
+function extractDetails(cause: Cause.Cause<unknown>): Array<TowerStore.TowerErrorDetail> {
+  const details: Array<TowerStore.TowerErrorDetail> = []
+
+  const failures = Chunk.toArray(Cause.failures(cause))
+  for (const error of failures) {
+    details.push({
+      kind: "fail",
+      tag: extractTag(error),
+      message: extractMessage(error),
+      properties: extractProperties(error),
+      span: extractSpanName(error),
+    })
+  }
+
+  const defects = Chunk.toArray(Cause.defects(cause))
+  for (const defect of defects) {
+    details.push({
+      kind: "die",
+      tag: extractTag(defect),
+      message: extractMessage(defect),
+      properties: extractProperties(defect),
+      span: extractSpanName(defect),
+    })
+  }
+
+  return details
+}
+
+function make(store: TowerStore.TowerStoreShape): Supervisor.Supervisor<void> {
+  return new (class extends Supervisor.AbstractSupervisor<void> {
+    value = Effect.void
+
+    onStart<A, E, R>(
+      _context: Context.Context<R>,
+      _effect: Effect.Effect<A, E, R>,
+      parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
+      fiber: Fiber.RuntimeFiber<A, E>,
+    ) {
+      const childId = FiberId.threadName(fiber.id())
+      const parentId = Option.isSome(parent) ? FiberId.threadName(parent.value.id()) : undefined
+
+      const span = fiber.currentSpan
+      const traceId = span
+        ? (() => {
+            try {
+              return BigInt(span.traceId)
+            } catch {
+              return undefined
+            }
+          })()
+        : undefined
+      const annotations: Record<string, unknown> = {}
+      const spanAnnotations = fiber.getFiberRef(FiberRef.currentTracerSpanAnnotations)
+      HashMap.forEach(spanAnnotations, (value, key) => {
+        annotations[key] = value
+      })
+      const logAnnotations = fiber.getFiberRef(FiberRef.currentLogAnnotations)
+      HashMap.forEach(logAnnotations, (value, key) => {
+        annotations[key] = value
+      })
+
+      TowerStore.runWrite(
+        TowerStore.upsertFiber(
+          store.sql,
+          childId,
+          parentId !== childId ? parentId : undefined,
+          span?._tag === "Span" ? span.name : undefined,
+          traceId,
+          annotations,
+        ),
+      )
+    }
+
+    onEnd<A, E>(exit: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>) {
+      if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause)) {
+        const error: TowerStore.TowerError = {
+          id: TowerStore.nextErrorId(),
+          fiberId: FiberId.threadName(fiber.id()),
+          interrupted: Cause.isInterrupted(exit.cause),
+          prettyPrint: Cause.pretty(exit.cause, { renderErrorCause: true }),
+          details: extractDetails(exit.cause),
+        }
+        TowerStore.runWrite(
+          Effect.zipRight(
+            TowerStore.insertError(store.sql, error),
+            TowerStore.evict(store.sql, "Error", store.errorCapacity),
+          ),
+        )
+        Effect.runSync(PubSub.publish(store.events, { _tag: "Error", error }))
+      }
+    }
+  })()
+}
+
+export const layer: Layer.Layer<never, never, TowerStore.TowerStore> = Layer.unwrapEffect(
+  Effect.gen(function* () {
+    const store = yield* TowerStore.TowerStore
+    return Supervisor.addSupervisor(make(store))
+  }),
+)

package/src/tower/TowerLogger.ts

@@ -0,0 +1,52 @@
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as FiberId from "effect/FiberId"
+import * as HashMap from "effect/HashMap"
+import * as List from "effect/List"
+import * as Logger from "effect/Logger"
+import * as PubSub from "effect/PubSub"
+import * as TowerStore from "./TowerStore.ts"
+
+const towerLogger = Logger.make((options) => {
+  const store = TowerStore.store
+  if (!store.sql) return
+
+  try {
+    const levelMap: Record<string, TowerStore.TowerLog["level"]> = {
+      Debug: "DEBUG",
+      Info: "INFO",
+      Warning: "WARNING",
+      Error: "ERROR",
+      Fatal: "FATAL",
+    }
+    const level = levelMap[options.logLevel._tag] ?? "INFO"
+    const causeStr = !Cause.isEmpty(options.cause)
+      ? Cause.pretty(options.cause, { renderErrorCause: true })
+      : undefined
+    const spanNames: Array<string> = []
+    List.forEach(options.spans, (s) => spanNames.push(s.label))
+    const ann: Record<string, unknown> = {}
+    HashMap.forEach(options.annotations, (v, k) => {
+      ann[k] = v
+    })
+
+    const log: TowerStore.TowerLog = {
+      id: TowerStore.nextLogId(),
+      level,
+      message: String(options.message),
+      fiberId: FiberId.threadName(options.fiberId),
+      cause: causeStr,
+      spans: spanNames,
+      annotations: ann,
+    }
+    TowerStore.runWrite(
+      Effect.zipRight(
+        TowerStore.insertLog(store.sql, log),
+        TowerStore.evict(store.sql, "Log", store.logCapacity),
+      ),
+    )
+    Effect.runSync(PubSub.publish(store.events, { _tag: "Log", log }))
+  } catch (_) {}
+})
+
+export const layer = Logger.add(towerLogger)

package/src/tower/TowerMetrics.ts

@@ -0,0 +1,72 @@
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Metric from "effect/Metric"
+import * as MetricKeyType from "effect/MetricKeyType"
+import * as PubSub from "effect/PubSub"
+import * as Schedule from "effect/Schedule"
+import * as TowerStore from "./TowerStore.ts"
+
+export const layer: Layer.Layer<never, never, TowerStore.TowerStore> = Layer.scopedDiscard(
+  Effect.gen(function* () {
+    const store = yield* TowerStore.TowerStore
+
+    yield* Effect.forkScoped(
+      Effect.schedule(
+        Effect.sync(() => {
+          const pairs = Metric.unsafeSnapshot()
+          const snapshots: Array<TowerStore.TowerMetricSnapshot> = []
+
+          for (const pair of pairs) {
+            const key = pair.metricKey
+            const state = pair.metricState as any
+            let type: TowerStore.TowerMetricSnapshot["type"] = "counter"
+            let value: unknown = 0
+
+            if (MetricKeyType.CounterKeyTypeTypeId in key.keyType) {
+              type = "counter"
+              value = state.count
+            } else if (MetricKeyType.GaugeKeyTypeTypeId in key.keyType) {
+              type = "gauge"
+              value = state.value
+            } else if (MetricKeyType.HistogramKeyTypeTypeId in key.keyType) {
+              type = "histogram"
+              value = {
+                buckets: state.buckets,
+                count: state.count,
+                sum: state.sum,
+                min: state.min,
+                max: state.max,
+              }
+            } else if (MetricKeyType.FrequencyKeyTypeTypeId in key.keyType) {
+              type = "frequency"
+              value = Object.fromEntries(state.occurrences)
+            } else if (MetricKeyType.SummaryKeyTypeTypeId in key.keyType) {
+              type = "summary"
+              value = {
+                quantiles: state.quantiles,
+                count: state.count,
+                sum: state.sum,
+                min: state.min,
+                max: state.max,
+              }
+            }
+
+            snapshots.push({
+              name: key.name,
+              type,
+              value,
+              tags: key.tags.map((t: any) => ({ key: t.key, value: t.value })),
+              timestamp: Date.now(),
+            })
+          }
+
+          store.metrics = snapshots
+          Effect.runSync(
+            PubSub.publish(store.events, { _tag: "MetricsSnapshot", metrics: snapshots }),
+          )
+        }),
+        Schedule.spaced("2 seconds"),
+      ),
+    )
+  }),
+)

package/src/tower/TowerProcess.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 TowerStore from "./TowerStore.ts"
+
+function snapshot(): TowerStore.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, TowerStore.TowerStore> = Layer.scopedDiscard(
+  Effect.gen(function* () {
+    const store = yield* TowerStore.TowerStore
+
+    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"),
+      ),
+    )
+  }),
+)