effect-start 0.25.0 → 0.26.0

package/dist/console/ConsoleLogger.js

@@ -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.js"
-
-let logId = 0
-
-export const layer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const store = yield* ConsoleStore.ConsoleStore
-
-    const logger = Logger.make(
-      ({ message, logLevel, cause, fiberId, spans, annotations, date }) => {
-        const levelMap = {
-          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 = []
-        List.forEach(spans, (s) => spanNames.push(s.label))
-        const ann = {}
-        HashMap.forEach(annotations, (v, k) => {
-          ann[k] = v
-        })
-
-        const log = {
-          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/dist/console/ConsoleMetrics.js

@@ -1,72 +0,0 @@
-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 ConsoleStore from "./ConsoleStore.js"
-
-export const layer = Layer.scopedDiscard(
-  Effect.gen(function* () {
-    const store = yield* ConsoleStore.ConsoleStore
-
-    yield* Effect.forkScoped(
-      Effect.schedule(
-        Effect.sync(() => {
-          const pairs = Metric.unsafeSnapshot()
-          const snapshots = []
-
-          for (const pair of pairs) {
-            const key = pair.metricKey
-            const state = pair.metricState
-            let type = "counter"
-            let value = 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) => ({ 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/dist/console/ConsoleProcess.js

@@ -1,59 +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.js

@@ -1,72 +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.js

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