@tungthedev/streams-server 0.2.0

package/src/sqlite/adapter.ts

@@ -0,0 +1,335 @@
+import { createRequire } from "node:module";
+import type { HostRuntime } from "../runtime/host_runtime.ts";
+import { detectHostRuntime } from "../runtime/host_runtime.ts";
+import { dsError } from "../util/ds_error.ts";
+export interface SqliteStatement {
+  get(...params: any[]): any;
+  all(...params: any[]): any[];
+  run(...params: any[]): { changes: number | bigint; lastInsertRowid: number | bigint };
+  iterate(...params: any[]): Iterable<any>;
+  finalize?(): void;
+}
+
+export interface SqliteDatabase {
+  exec(sql: string): void;
+  query(sql: string): SqliteStatement;
+  prepare(sql: string): SqliteStatement;
+  transaction<T>(fn: () => T): () => T;
+  close(): void;
+}
+
+type SqliteAdapterRuntimeCounts = {
+  open_connections: number;
+  prepared_statements: number;
+};
+
+const sqliteAdapterRuntimeCounts: SqliteAdapterRuntimeCounts = {
+  open_connections: 0,
+  prepared_statements: 0,
+};
+
+function incrementSqliteConnection(): void {
+  sqliteAdapterRuntimeCounts.open_connections += 1;
+}
+
+function decrementSqliteConnection(): void {
+  sqliteAdapterRuntimeCounts.open_connections = Math.max(0, sqliteAdapterRuntimeCounts.open_connections - 1);
+}
+
+function incrementPreparedStatement(): void {
+  sqliteAdapterRuntimeCounts.prepared_statements += 1;
+}
+
+function decrementPreparedStatement(): void {
+  sqliteAdapterRuntimeCounts.prepared_statements = Math.max(0, sqliteAdapterRuntimeCounts.prepared_statements - 1);
+}
+
+export function getSqliteAdapterRuntimeCounts(): SqliteAdapterRuntimeCounts {
+  return { ...sqliteAdapterRuntimeCounts };
+}
+
+class BunStatementAdapter implements SqliteStatement {
+  private readonly stmt: any;
+  private readonly onFinalize?: () => void;
+  private finalized = false;
+
+  constructor(stmt: any, onFinalize?: () => void) {
+    this.stmt = stmt;
+    this.onFinalize = onFinalize;
+  }
+
+  get(...params: any[]): any {
+    return this.stmt.get(...params);
+  }
+
+  all(...params: any[]): any[] {
+    return this.stmt.all(...params);
+  }
+
+  run(...params: any[]): { changes: number | bigint; lastInsertRowid: number | bigint } {
+    return this.stmt.run(...params);
+  }
+
+  iterate(...params: any[]): Iterable<any> {
+    return this.stmt.iterate(...params);
+  }
+
+  finalize(): void {
+    if (this.finalized) return;
+    this.finalized = true;
+    try {
+      if (typeof this.stmt.finalize === "function") this.stmt.finalize();
+    } finally {
+      this.onFinalize?.();
+    }
+  }
+}
+
+class BunDatabaseAdapter implements SqliteDatabase {
+  private readonly db: any;
+  private preparedStatementCount = 0;
+  private closed = false;
+  private readonly statementCache = new Map<string, BunStatementAdapter>();
+
+  constructor(db: any) {
+    this.db = db;
+    incrementSqliteConnection();
+  }
+
+  private trackStatement(): () => void {
+    let released = false;
+    this.preparedStatementCount += 1;
+    incrementPreparedStatement();
+    return () => {
+      if (released) return;
+      released = true;
+      this.preparedStatementCount = Math.max(0, this.preparedStatementCount - 1);
+      decrementPreparedStatement();
+    };
+  }
+
+  exec(sql: string): void {
+    this.db.exec(sql);
+  }
+
+  prepare(sql: string): SqliteStatement {
+    return new BunStatementAdapter(this.db.query(sql), this.trackStatement());
+  }
+
+  query(sql: string): SqliteStatement {
+    const cached = this.statementCache.get(sql);
+    if (cached) return cached;
+    let adapter: BunStatementAdapter;
+    const release = this.trackStatement();
+    adapter = new BunStatementAdapter(this.db.query(sql), () => {
+      this.statementCache.delete(sql);
+      release();
+    });
+    this.statementCache.set(sql, adapter);
+    return adapter;
+  }
+
+  transaction<T>(fn: () => T): () => T {
+    return this.db.transaction(fn);
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    const cachedStatements = Array.from(this.statementCache.values());
+    this.statementCache.clear();
+    for (const stmt of cachedStatements) {
+      try {
+        stmt.finalize?.();
+      } catch {
+        // Ignore finalizer failures during shutdown.
+      }
+    }
+    while (this.preparedStatementCount > 0) {
+      this.preparedStatementCount -= 1;
+      decrementPreparedStatement();
+    }
+    try {
+      this.db.close();
+    } finally {
+      decrementSqliteConnection();
+    }
+  }
+}
+
+class NodeStatementAdapter implements SqliteStatement {
+  private readonly stmt: any;
+  private readonly onFinalize?: () => void;
+  private finalized = false;
+
+  constructor(stmt: any, onFinalize?: () => void) {
+    this.stmt = stmt;
+    this.onFinalize = onFinalize;
+  }
+
+  get(...params: any[]): any {
+    return this.stmt.get(...params);
+  }
+
+  all(...params: any[]): any[] {
+    return this.stmt.all(...params);
+  }
+
+  run(...params: any[]): { changes: number | bigint; lastInsertRowid: number | bigint } {
+    return this.stmt.run(...params);
+  }
+
+  iterate(...params: any[]): Iterable<any> {
+    return this.stmt.iterate(...params);
+  }
+
+  finalize(): void {
+    if (this.finalized) return;
+    this.finalized = true;
+    try {
+      if (typeof this.stmt.finalize === "function") this.stmt.finalize();
+    } finally {
+      this.onFinalize?.();
+    }
+  }
+}
+
+class NodeDatabaseAdapter implements SqliteDatabase {
+  private txDepth = 0;
+  private txCounter = 0;
+  private readonly db: any;
+  private preparedStatementCount = 0;
+  private closed = false;
+  private readonly statementCache = new Map<string, NodeStatementAdapter>();
+
+  constructor(db: any) {
+    this.db = db;
+    incrementSqliteConnection();
+  }
+
+  private trackStatement(): () => void {
+    let released = false;
+    this.preparedStatementCount += 1;
+    incrementPreparedStatement();
+    return () => {
+      if (released) return;
+      released = true;
+      this.preparedStatementCount = Math.max(0, this.preparedStatementCount - 1);
+      decrementPreparedStatement();
+    };
+  }
+
+  exec(sql: string): void {
+    this.db.exec(sql);
+  }
+
+  prepare(sql: string): SqliteStatement {
+    const stmt = this.db.prepare(sql);
+    if (typeof stmt?.setReadBigInts === "function") stmt.setReadBigInts(true);
+    return new NodeStatementAdapter(stmt, this.trackStatement());
+  }
+
+  query(sql: string): SqliteStatement {
+    const cached = this.statementCache.get(sql);
+    if (cached) return cached;
+    const stmt = this.db.prepare(sql);
+    if (typeof stmt?.setReadBigInts === "function") stmt.setReadBigInts(true);
+    let adapter: NodeStatementAdapter;
+    const release = this.trackStatement();
+    adapter = new NodeStatementAdapter(stmt, () => {
+      this.statementCache.delete(sql);
+      release();
+    });
+    this.statementCache.set(sql, adapter);
+    return adapter;
+  }
+
+  transaction<T>(fn: () => T): () => T {
+    return () => {
+      const nested = this.txDepth > 0;
+      const savepoint = `ds_tx_${++this.txCounter}`;
+      this.txDepth += 1;
+      try {
+        if (nested) this.db.exec(`SAVEPOINT ${savepoint};`);
+        else this.db.exec("BEGIN;");
+        const out = fn();
+        if (nested) this.db.exec(`RELEASE SAVEPOINT ${savepoint};`);
+        else this.db.exec("COMMIT;");
+        return out;
+      } catch (err) {
+        try {
+          if (nested) {
+            this.db.exec(`ROLLBACK TO SAVEPOINT ${savepoint};`);
+            this.db.exec(`RELEASE SAVEPOINT ${savepoint};`);
+          } else {
+            this.db.exec("ROLLBACK;");
+          }
+        } catch {
+          // Ignore secondary rollback failures.
+        }
+        throw err;
+      } finally {
+        this.txDepth = Math.max(0, this.txDepth - 1);
+      }
+    };
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    const cachedStatements = Array.from(this.statementCache.values());
+    this.statementCache.clear();
+    for (const stmt of cachedStatements) {
+      try {
+        stmt.finalize?.();
+      } catch {
+        // Ignore finalizer failures during shutdown.
+      }
+    }
+    while (this.preparedStatementCount > 0) {
+      this.preparedStatementCount -= 1;
+      decrementPreparedStatement();
+    }
+    try {
+      this.db.close();
+    } finally {
+      decrementSqliteConnection();
+    }
+  }
+}
+
+let openImpl: ((path: string) => SqliteDatabase) | null = null;
+let openImplRuntime: HostRuntime | null = null;
+let runtimeOverride: HostRuntime | null = null;
+const require = createRequire(import.meta.url);
+
+function selectedRuntime(): HostRuntime {
+  return runtimeOverride ?? detectHostRuntime();
+}
+
+function buildOpenImpl(runtime: HostRuntime): (path: string) => SqliteDatabase {
+  if (runtime === "bun") {
+    const { Database } = require("bun:sqlite") as { Database: new (path: string) => any };
+    return (path: string) => new BunDatabaseAdapter(new Database(path));
+  }
+  const { DatabaseSync } = require("node:sqlite") as { DatabaseSync: new (path: string) => any };
+  return (path: string) => new NodeDatabaseAdapter(new DatabaseSync(path));
+}
+
+export function setSqliteRuntimeOverride(runtime: HostRuntime | null): void {
+  runtimeOverride = runtime;
+  if (runtimeOverride && openImplRuntime && runtimeOverride !== openImplRuntime) {
+    openImpl = null;
+    openImplRuntime = null;
+  }
+}
+
+export function openSqliteDatabase(path: string): SqliteDatabase {
+  const runtime = selectedRuntime();
+  if (!openImpl || openImplRuntime !== runtime) {
+    openImpl = buildOpenImpl(runtime);
+    openImplRuntime = runtime;
+  }
+  if (!openImpl) throw dsError("sqlite adapter not initialized");
+  return openImpl(path);
+}

package/src/sqlite/runtime_stats.ts

@@ -0,0 +1,163 @@
+import { createRequire } from "node:module";
+import { detectHostRuntime } from "../runtime/host_runtime.ts";
+import { getSqliteAdapterRuntimeCounts } from "./adapter.ts";
+import type { SqliteRuntimeMemoryStats } from "../runtime_memory.ts";
+
+const SQLITE_STATUS_MEMORY_USED = 0;
+const SQLITE_STATUS_PAGECACHE_USED = 1;
+const SQLITE_STATUS_PAGECACHE_OVERFLOW = 2;
+const SQLITE_STATUS_MALLOC_COUNT = 9;
+
+type SqliteStatus64Fn = (op: number, currentPtr: number, highwaterPtr: number, resetFlag: number) => number;
+type BunFfiModule = {
+  dlopen: (
+    path: string,
+    symbols: {
+      sqlite3_status64: {
+        args: ["i32", "ptr", "ptr", "i32"];
+        returns: "i32";
+      };
+    }
+  ) => { symbols: { sqlite3_status64: SqliteStatus64Fn }; close: () => void };
+  ptr: (value: TypedArray) => number;
+};
+
+type TypedArray = BigInt64Array | BigUint64Array | Int32Array | Uint32Array;
+
+type SqliteLibraryHandle = {
+  sqlite3_status64: SqliteStatus64Fn;
+  close: () => void;
+};
+
+type CachedSqliteRuntimeStats = {
+  at_ms: number;
+  value: SqliteRuntimeMemoryStats;
+};
+
+let ffiModule: BunFfiModule | null | undefined;
+let sqliteLibrary: SqliteLibraryHandle | null | undefined;
+let cachedRuntimeStats: CachedSqliteRuntimeStats | null = null;
+const require = createRequire(import.meta.url);
+
+function sqliteLibraryNames(): string[] {
+  if (process.platform === "darwin") {
+    return ["libsqlite3.dylib", "/usr/lib/libsqlite3.dylib"];
+  }
+  if (process.platform === "linux") {
+    return ["libsqlite3.so.0", "libsqlite3.so", "/usr/lib/x86_64-linux-gnu/libsqlite3.so.0", "/lib/x86_64-linux-gnu/libsqlite3.so.0"];
+  }
+  return ["libsqlite3.so", "libsqlite3.dylib"];
+}
+
+function loadBunFfi(): BunFfiModule | null {
+  if (ffiModule !== undefined) return ffiModule;
+  if (detectHostRuntime() !== "bun") {
+    ffiModule = null;
+    return ffiModule;
+  }
+  try {
+    ffiModule = require("bun:ffi") as BunFfiModule;
+  } catch {
+    ffiModule = null;
+  }
+  return ffiModule;
+}
+
+function loadSqliteLibrary(): SqliteLibraryHandle | null {
+  if (sqliteLibrary !== undefined) return sqliteLibrary;
+  const ffi = loadBunFfi();
+  if (!ffi) {
+    sqliteLibrary = null;
+    return sqliteLibrary;
+  }
+  for (const name of sqliteLibraryNames()) {
+    try {
+      const lib = ffi.dlopen(name, {
+        sqlite3_status64: {
+          args: ["i32", "ptr", "ptr", "i32"],
+          returns: "i32",
+        },
+      });
+      sqliteLibrary = {
+        sqlite3_status64: lib.symbols.sqlite3_status64,
+        close: () => lib.close(),
+      };
+      return sqliteLibrary;
+    } catch {
+      // Try the next library name.
+    }
+  }
+  sqliteLibrary = null;
+  return sqliteLibrary;
+}
+
+function readStatus64(
+  lib: SqliteLibraryHandle,
+  ffi: BunFfiModule,
+  op: number
+): { current: number; highwater: number } | null {
+  const current = new BigInt64Array(1);
+  const highwater = new BigInt64Array(1);
+  try {
+    const rc = lib.sqlite3_status64(op, ffi.ptr(current), ffi.ptr(highwater), 0);
+    if (rc !== 0) return null;
+    return {
+      current: Number(current[0]),
+      highwater: Number(highwater[0]),
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function readSqliteRuntimeMemoryStats(ttlMs = 1_000): SqliteRuntimeMemoryStats {
+  const now = Date.now();
+  if (cachedRuntimeStats && now - cachedRuntimeStats.at_ms < Math.max(0, ttlMs)) {
+    return cachedRuntimeStats.value;
+  }
+
+  const adapterCounts = getSqliteAdapterRuntimeCounts();
+  const unavailable: SqliteRuntimeMemoryStats = {
+    available: false,
+    source: "unavailable",
+    memory_used_bytes: 0,
+    memory_highwater_bytes: 0,
+    pagecache_used_slots: 0,
+    pagecache_used_slots_highwater: 0,
+    pagecache_overflow_bytes: 0,
+    pagecache_overflow_highwater_bytes: 0,
+    malloc_count: 0,
+    malloc_count_highwater: 0,
+    open_connections: adapterCounts.open_connections,
+    prepared_statements: adapterCounts.prepared_statements,
+  };
+
+  const ffi = loadBunFfi();
+  const lib = loadSqliteLibrary();
+  if (!ffi || !lib) {
+    cachedRuntimeStats = { at_ms: now, value: unavailable };
+    return unavailable;
+  }
+
+  const memoryUsed = readStatus64(lib, ffi, SQLITE_STATUS_MEMORY_USED);
+  const pagecacheUsed = readStatus64(lib, ffi, SQLITE_STATUS_PAGECACHE_USED);
+  const pagecacheOverflow = readStatus64(lib, ffi, SQLITE_STATUS_PAGECACHE_OVERFLOW);
+  const mallocCount = readStatus64(lib, ffi, SQLITE_STATUS_MALLOC_COUNT);
+
+  const stats: SqliteRuntimeMemoryStats = {
+    available: memoryUsed != null,
+    source: memoryUsed != null ? "sqlite3_status64" : "unavailable",
+    memory_used_bytes: Math.max(0, Math.floor(memoryUsed?.current ?? 0)),
+    memory_highwater_bytes: Math.max(0, Math.floor(memoryUsed?.highwater ?? 0)),
+    pagecache_used_slots: Math.max(0, Math.floor(pagecacheUsed?.current ?? 0)),
+    pagecache_used_slots_highwater: Math.max(0, Math.floor(pagecacheUsed?.highwater ?? 0)),
+    pagecache_overflow_bytes: Math.max(0, Math.floor(pagecacheOverflow?.current ?? 0)),
+    pagecache_overflow_highwater_bytes: Math.max(0, Math.floor(pagecacheOverflow?.highwater ?? 0)),
+    malloc_count: Math.max(0, Math.floor(mallocCount?.current ?? 0)),
+    malloc_count_highwater: Math.max(0, Math.floor(mallocCount?.highwater ?? 0)),
+    open_connections: adapterCounts.open_connections,
+    prepared_statements: adapterCounts.prepared_statements,
+  };
+  cachedRuntimeStats = { at_ms: now, value: stats };
+  return stats;
+}

package/src/stats.ts

@@ -0,0 +1,205 @@
+import type { UploaderController } from "./uploader";
+import type { MemoryPressureMonitor } from "./memory";
+import type { BackpressureGate } from "./backpressure";
+import type { IngestQueue } from "./ingest";
+import type { StorageStatsStore } from "./store/stats_accounting_store";
+
+export type StatsSnapshot = {
+  ingestedBytes: number;
+  walBytes: number;
+  sealedPayloadBytes: number;
+  sealedBytes: number;
+  uploadedBytes: number;
+  segmentsSealed: number;
+  backpressureOverMs: number;
+  activeStreams: number;
+};
+
+export class StatsCollector {
+  private readonly backpressureBudgetMs: number;
+  private ingestedBytes = 0;
+  private walBytes = 0;
+  private sealedPayloadBytes = 0;
+  private sealedBytes = 0;
+  private uploadedBytes = 0;
+  private segmentsSealed = 0;
+  private backpressureOverMs = 0;
+  private readonly activeStreams = new Set<string>();
+
+  constructor(opts?: { backpressureBudgetMs?: number }) {
+    const raw = opts?.backpressureBudgetMs ?? 1;
+    this.backpressureBudgetMs = Number.isFinite(raw) ? Math.max(0, raw) : 1;
+  }
+
+  recordIngested(bytes: number): void {
+    this.ingestedBytes += bytes;
+  }
+
+  recordWalCommitBytes(bytes: number): void {
+    this.walBytes += bytes;
+  }
+
+  recordSegmentSealed(payloadBytes: number, segmentBytes: number): void {
+    this.sealedPayloadBytes += payloadBytes;
+    this.sealedBytes += segmentBytes;
+    this.segmentsSealed += 1;
+  }
+
+  recordUploadedBytes(bytes: number): void {
+    this.uploadedBytes += bytes;
+  }
+
+  getBackpressureBudgetMs(): number {
+    return this.backpressureBudgetMs;
+  }
+
+  recordBackpressureOverMs(overMs: number): void {
+    if (overMs <= 0) return;
+    this.backpressureOverMs += Math.max(0, overMs);
+  }
+
+  recordStreamTouched(stream: string): void {
+    this.activeStreams.add(stream);
+  }
+
+  snapshotAndReset(): StatsSnapshot {
+    const snapshot: StatsSnapshot = {
+      ingestedBytes: this.ingestedBytes,
+      walBytes: this.walBytes,
+      sealedPayloadBytes: this.sealedPayloadBytes,
+      sealedBytes: this.sealedBytes,
+      uploadedBytes: this.uploadedBytes,
+      segmentsSealed: this.segmentsSealed,
+      backpressureOverMs: this.backpressureOverMs,
+      activeStreams: this.activeStreams.size,
+    };
+    this.ingestedBytes = 0;
+    this.walBytes = 0;
+    this.sealedPayloadBytes = 0;
+    this.sealedBytes = 0;
+    this.uploadedBytes = 0;
+    this.segmentsSealed = 0;
+    this.backpressureOverMs = 0;
+    this.activeStreams.clear();
+    return snapshot;
+  }
+}
+
+function formatBytes(bytes: number): string {
+  const units = ["b", "kb", "mb", "gb"];
+  let value = bytes;
+  let idx = 0;
+  while (value >= 1024 && idx < units.length - 1) {
+    value /= 1024;
+    idx += 1;
+  }
+  const digits = idx === 0 ? 0 : 1;
+  return `${value.toFixed(digits)}${units[idx]}`;
+}
+
+export class StatsReporter {
+  private timer: any | null = null;
+  private sampleTimer: any | null = null;
+  private running = false;
+  private lastTickMs: number | null = null;
+  private lastSampleMs: number | null = null;
+  private rejectActiveMs = 0;
+  private readonly intervalMs: number;
+  private readonly stats: StatsCollector;
+  private readonly storageStats: StorageStatsStore;
+  private readonly uploader: UploaderController;
+  private readonly ingest?: IngestQueue;
+  private readonly backpressure?: BackpressureGate;
+  private readonly memory?: MemoryPressureMonitor;
+
+  constructor(
+    stats: StatsCollector,
+    storageStats: StorageStatsStore,
+    uploader: UploaderController,
+    ingest?: IngestQueue,
+    backpressure?: BackpressureGate,
+    memory?: MemoryPressureMonitor,
+    intervalMs = 60_000
+  ) {
+    this.stats = stats;
+    this.storageStats = storageStats;
+    this.uploader = uploader;
+    this.ingest = ingest;
+    this.backpressure = backpressure;
+    this.memory = memory;
+    this.intervalMs = intervalMs;
+  }
+
+  start(): void {
+    if (this.timer) return;
+    if (!this.sampleTimer) {
+      this.sampleTimer = setInterval(() => this.sample(), 250);
+      this.sample();
+    }
+    this.timer = setInterval(() => {
+      void this.tick();
+    }, this.intervalMs);
+  }
+
+  stop(): void {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    if (this.sampleTimer) clearInterval(this.sampleTimer);
+    this.sampleTimer = null;
+  }
+
+  private sample(): void {
+    const now = Date.now();
+    const last = this.lastSampleMs;
+    this.lastSampleMs = now;
+    if (!last) return;
+    const dt = Math.max(0, now - last);
+
+    const rejectActive =
+      (this.memory?.isOverLimit() ?? false) ||
+      (this.ingest?.isQueueFull() ?? false) ||
+      (this.backpressure?.isOverLimit() ?? false);
+    if (rejectActive) this.rejectActiveMs += dt;
+  }
+
+  private async tick(): Promise<void> {
+    if (this.running) return;
+    this.running = true;
+    try {
+      const nowMs = Date.now();
+      const windowMs = this.lastTickMs ? Math.max(1, nowMs - this.lastTickMs) : this.intervalMs;
+      this.lastTickMs = nowMs;
+      const snap = this.stats.snapshotAndReset();
+      const storedBytes = snap.walBytes + snap.sealedBytes;
+      const compression =
+        snap.sealedBytes > 0 ? `${(snap.sealedPayloadBytes / snap.sealedBytes).toFixed(2)}x` : "n/a";
+      const queueWaitPct = snap.backpressureOverMs > 0 ? (snap.backpressureOverMs / windowMs) * 100 : 0;
+      const rejectPct = this.rejectActiveMs > 0 ? (this.rejectActiveMs / windowMs) * 100 : 0;
+      const backpressurePct = Math.min(100, Math.max(queueWaitPct, rejectPct));
+      this.rejectActiveMs = 0;
+      const avgSegmentSize = snap.segmentsSealed > 0 ? formatBytes(snap.sealedBytes / snap.segmentsSealed) : "n/a";
+      const totalStreams = await this.storageStats.countStreams();
+      const segmentsWaiting = this.uploader.countSegmentsWaiting();
+      const walDbBytes = await this.storageStats.getWalDbSizeBytes();
+      const metaDbBytes = await this.storageStats.getMetaDbSizeBytes();
+      const maxRss = this.memory ? formatBytes(this.memory.snapshotMaxRssBytes(true)) : null;
+      const line =
+        `ingested=${formatBytes(snap.ingestedBytes)} ` +
+        `stored=${formatBytes(storedBytes)} ` +
+        `compression=${compression} ` +
+        `uploaded=${formatBytes(snap.uploadedBytes)} ` +
+        `streams-touched=${snap.activeStreams}/${totalStreams} ` +
+        `segments-sealed=${snap.segmentsSealed} ` +
+        `segments-waiting=${segmentsWaiting} ` +
+        `avg-segment-size=${avgSegmentSize} ` +
+        `wal-size=${formatBytes(walDbBytes)} ` +
+        `meta-size=${formatBytes(metaDbBytes)} ` +
+        `backpressure=${backpressurePct.toFixed(1)}%` +
+        (maxRss ? ` max-rss=${maxRss}` : "");
+      // eslint-disable-next-line no-console
+      console.log(line);
+    } finally {
+      this.running = false;
+    }
+  }
+}