@ngockhoale/ukit 3.0.12 → 3.1.1

package/src/core/observability/emit/lifecycle.js

@@ -0,0 +1,349 @@
+/**
+ * lifecycle.js (TASK-005, SPEC §5 DF2-FR05, §6, §10) — the live recorder
+ * for a `ukit` process.
+ *
+ *   getRecorder({ projectRoot, config, recorderOpts? }) → recorder
+ *   startLifecycle({ projectRoot, config, recorder?, flushIntervalMs?,
+ *                    exitDeadlineMs?, registerCrashCapture?,
+ *                    projectionIntervalMs?, refreshSupport? }) → { stop() }
+ *   recorderHealth({ projectRoot? }?) → counters
+ *   resetForTests()
+ *
+ * Layout under the project (all bounded, covered by the existing `/.ukit/`
+ * gitignore rule — no new ignore machinery):
+ *
+ *   .ukit/storage/observability/          observability root (crashes/)
+ *   .ukit/storage/observability/segments/ segment root (active.jsonl + sealed)
+ *
+ * Contracts (SPEC §8):
+ *   - getRecorder memoizes one recorder per (segment root, boot_id): the
+ *     memo key is the resolved projectRoot and a recorder lives for the
+ *     process boot, so the pair is one entry. The config object supplied
+ *     on the FIRST call for a root is the one the recorder resolves
+ *     against — pass the live runtime config object so stage flips (the
+ *     kill switch) take effect; later calls with different config objects
+ *     do not re-create the recorder.
+ *   - Missing/invalid projectRoot → a memoized DISABLED recorder: emit()
+ *     → { status:'dropped', reason:'recorder-disabled' }, flush() a typed
+ *     no-op, health() zeroed. Callers (CLI, ingest, doctor) never special-
+ *     case a null recorder.
+ *   - startLifecycle wires an unref'd interval flush (default 30s, no
+ *     deadline — reliability over latency), a `beforeExit` flush bounded
+ *     by exitDeadlineMs (default 2s, runs at most once per start), and
+ *     crash capture under the observability root. stop() clears every
+ *     handle and awaits any in-flight flush so no timer/handler can leak
+ *     or pin the event loop.
+ *   - DF2-FR12 (TASK-012): startLifecycle also wires a second unref'd
+ *     interval (default 15min — `observability.projector.min_interval_ms`
+ *     lengthens it; `projectionIntervalMs` overrides wholesale for tests;
+ *     the stamp gate in schedule.js always enforces the ≥15min floor
+ *     between writes) calling the support-projection seam:
+ *     `refreshSupport` when injected, else `maybeRefreshSupport` from
+ *     ../support/schedule.js via dynamic import so the emit hot path
+ *     never eagerly loads the projector graph. Refresh ticks are
+ *     serialized by projectionInFlight and awaited by stop() like the
+ *     flush lane.
+ *   - Crash capture is stage-gated at start: with stage 'off' nothing is
+ *     written anywhere — "off" is the kill switch for disk too. (A later
+ *     runtime promotion mid-process does not retro-install capture; the
+ *     stage is read at startLifecycle time.)
+ *   - The exit flush is serialized through recorder.flush() itself, so a
+ *     slow writer can only consume the deadline — the process never hangs
+ *     on telemetry. The beforeExit handler self-guards against re-entry
+ *     (beforeExit re-emits whenever an async handler keeps the loop alive,
+ *     so an unguarded handler would flush forever and prevent exit).
+ *   - recorderHealth() merges the recorder's own counters with lifecycle
+ *     state and flat aliases: emitted (=accepted into queue), dropped
+ *     (all drop counters summed), flushed (=written to disk). All values
+ *     are 'unknown'-friendly: absent recorder → zeroed counters.
+ *
+ * No LLM, no daemon, no sync fs on the hot path. The module never throws.
+ */
+
+import path from 'node:path';
+
+import { createRecorder } from './recorder.js';
+import { registerCrashCapture } from './crash.js';
+import { resolveStage } from './config.js';
+
+const DEFAULT_FLUSH_INTERVAL_MS = 30_000;
+const DEFAULT_EXIT_DEADLINE_MS = 2_000;
+
+// Mirrors MIN_PROJECTION_INTERVAL_MS in ../support/schedule.js — kept local
+// so the emit hot path never eagerly loads the projector graph (the refresh
+// seam itself is reached via dynamic import inside the timer tick).
+const PROJECTION_FLOOR_INTERVAL_MS = 15 * 60 * 1000;
+
+function projectionIntervalOf(config, overrideMs) {
+  if (Number.isFinite(overrideMs) && overrideMs > 0) return overrideMs;
+  const node = config && typeof config === 'object' ? config.observability : undefined;
+  const projector = node && typeof node === 'object' && !Array.isArray(node)
+    ? node.projector
+    : undefined;
+  const raw = projector && typeof projector === 'object' && !Array.isArray(projector)
+    ? projector.min_interval_ms
+    : undefined;
+  const interval = Number.isFinite(raw) && raw > 0 ? raw : PROJECTION_FLOOR_INTERVAL_MS;
+  return Math.max(interval, PROJECTION_FLOOR_INTERVAL_MS);
+}
+
+/** `<projectRoot>/.ukit/storage/observability` — crashes + diagnostics. */
+export function observabilityRoot(projectRoot) {
+  return path.join(projectRoot, '.ukit', 'storage', 'observability');
+}
+
+/** `<projectRoot>/.ukit/storage/observability/segments` — recorder root. */
+export function segmentsRoot(projectRoot) {
+  return path.join(observabilityRoot(projectRoot), 'segments');
+}
+
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.length > 0;
+}
+
+// --- disabled recorder (SPEC §8: missing root → emit→dropped/recorder-disabled)
+
+function makeDisabledRecorder() {
+  const noop = () => {};
+  const health = () => ({
+    stage: 'off',
+    queue_depth: 0,
+    queue_bound: 0,
+    accepted: 0,
+    written: 0,
+    dropped_stage_off: 0,
+    dropped_invalid: 0,
+    dropped_sanitized: 0,
+    dropped_oldest: 0,
+    dropped_write: 0,
+    write_failures: 0,
+    dropped_sampled: 0,
+    invalid_spans: 0,
+    flushes: 0,
+    last_flush: null,
+    last_error: null,
+  });
+  return {
+    emit: () => ({ status: 'dropped', reason: 'recorder-disabled' }),
+    startSpan: () => ({ ended: true }),
+    endSpan: noop,
+    flush: async () => ({ status: 'ok', written: 0, dropped: 0, remaining: 0, elapsed_ms: 0 }),
+    health,
+    // Contract marker so downstream surfaces can distinguish a disabled
+    // recorder from a staged one without guessing from counters.
+    disabled: true,
+  };
+}
+
+// --- module state ------------------------------------------------------------
+
+const recorders = new Map(); // projectRoot → recorder
+const DISABLED_KEY = Symbol('disabled');
+let disabledRecorder = null;
+let lastProjectRoot = null;
+
+const lifecycle = {
+  running: false,
+  interval: null,
+  clearIntervalFn: null,
+  beforeExit: null,
+  capture: null,
+  recorder: null,
+  inFlight: null,
+  exitFlushed: false,
+  projection: null,
+  projectionInFlight: null,
+};
+
+export function getRecorder({ projectRoot, config, recorderOpts } = {}) {
+  if (!isNonEmptyString(projectRoot)) {
+    if (disabledRecorder === null) disabledRecorder = makeDisabledRecorder();
+    return disabledRecorder;
+  }
+  const key = path.resolve(projectRoot);
+  lastProjectRoot = key;
+  const existing = recorders.get(key);
+  if (existing) return existing;
+  const opts = recorderOpts && typeof recorderOpts === 'object' ? recorderOpts : {};
+  const recorder = createRecorder({
+    ...opts,
+    root: segmentsRoot(key),
+    config,
+  });
+  recorders.set(key, recorder);
+  return recorder;
+}
+
+function detachLifecycle() {
+  if (lifecycle.interval !== null) {
+    (lifecycle.clearIntervalFn || clearInterval)(lifecycle.interval);
+  }
+  clearInterval(lifecycle.projection);
+  if (lifecycle.beforeExit !== null) {
+    process.removeListener('beforeExit', lifecycle.beforeExit);
+  }
+  if (lifecycle.capture && typeof lifecycle.capture.dispose === 'function') {
+    try { lifecycle.capture.dispose(); } catch {}
+  }
+  lifecycle.interval = null;
+  lifecycle.clearIntervalFn = null;
+  lifecycle.projection = null;
+  lifecycle.projectionInFlight = null;
+  lifecycle.beforeExit = null;
+  lifecycle.capture = null;
+  lifecycle.recorder = null;
+  lifecycle.exitFlushed = false;
+  lifecycle.running = false;
+}
+
+export function startLifecycle({
+  projectRoot,
+  config,
+  recorder,
+  flushIntervalMs,
+  exitDeadlineMs,
+  registerCrashCapture: captureImpl,
+  projectionIntervalMs,
+  refreshSupport,
+} = {}) {
+  // Idempotent restart: a second start replaces the wiring rather than
+  // stacking listeners/timers.
+  detachLifecycle();
+  const rec = recorder || getRecorder({ projectRoot, config });
+  if (isNonEmptyString(projectRoot)) lastProjectRoot = path.resolve(projectRoot);
+
+  const intervalMs = Number.isFinite(flushIntervalMs) && flushIntervalMs > 0
+    ? flushIntervalMs
+    : DEFAULT_FLUSH_INTERVAL_MS;
+  const deadlineMs = Number.isFinite(exitDeadlineMs) && exitDeadlineMs > 0
+    ? exitDeadlineMs
+    : DEFAULT_EXIT_DEADLINE_MS;
+  const installCapture = typeof captureImpl === 'function' ? captureImpl : registerCrashCapture;
+
+  // Reliability lane: the periodic flush has no deadline — it drains at
+  // the writer's own pace and is serialized with any other in-flight pump.
+  const onTick = () => {
+    const run = rec.flush();
+    lifecycle.inFlight = run;
+    run.finally(() => {
+      if (lifecycle.inFlight === run) lifecycle.inFlight = null;
+    });
+    // fire-and-forget: pump() never rejects, belt-and-suspenders anyway
+    run.catch(() => {});
+  };
+  const interval = setInterval(onTick, intervalMs);
+  if (typeof interval.unref === 'function') interval.unref();
+
+  // Exit lane: bounded flush. beforeExit re-fires while an async handler
+  // keeps work alive, so run it at most once — a slow writer must not
+  // turn telemetry into an exit hang.
+  const onBeforeExit = () => {
+    if (lifecycle.exitFlushed) return;
+    lifecycle.exitFlushed = true;
+    const run = rec.flush({ deadlineMs });
+    lifecycle.inFlight = run;
+    run.finally(() => {
+      if (lifecycle.inFlight === run) lifecycle.inFlight = null;
+    });
+    run.catch(() => {});
+  };
+  process.on('beforeExit', onBeforeExit);
+
+  // Crash capture is diagnostics, not emission — but stage 'off' means
+  // zero disk writes (the kill switch extends to disk), so it installs
+  // only when the stage is live at start time.
+  let capture = null;
+  if (resolveStage(config) !== 'off') {
+    try {
+      const ids = rec.health();
+      capture = installCapture({
+        root: observabilityRoot(path.resolve(projectRoot)),
+        writerId: ids.writer_id,
+        bootId: ids.boot_id,
+      });
+    } catch {
+      capture = null; // best-effort: capture failure never breaks lifecycle
+    }
+  }
+
+  // DF2-FR12 scheduled support refresh: unref'd timer on the same lifecycle
+  // — the emit hot path stays free of the projector graph because the
+  // default seam is a dynamic import resolved on the first tick. Ticks
+  // overlap-guard via projectionInFlight (a slow projection skips the next
+  // tick rather than stacking concurrent writes).
+  const projectionMs = projectionIntervalOf(config, projectionIntervalMs);
+  const refreshImpl =
+    typeof refreshSupport === 'function'
+      ? refreshSupport
+      : async (opts) => {
+          const { maybeRefreshSupport } = await import('../support/schedule.js');
+          return maybeRefreshSupport(opts);
+        };
+  const onProjectionTick = () => {
+    if (lifecycle.projectionInFlight) return;
+    const run = Promise.resolve()
+      .then(() => refreshImpl({ projectRoot, config, recorder: rec }))
+      .catch(() => {});
+    lifecycle.projectionInFlight = run;
+    run.finally(() => {
+      if (lifecycle.projectionInFlight === run) lifecycle.projectionInFlight = null;
+    });
+  };
+  const projection = setInterval(onProjectionTick, projectionMs);
+  if (typeof projection.unref === 'function') projection.unref();
+
+  lifecycle.running = true;
+  lifecycle.interval = interval;
+  lifecycle.clearIntervalFn = clearInterval;
+  lifecycle.beforeExit = onBeforeExit;
+  lifecycle.capture = capture;
+  lifecycle.recorder = rec;
+  lifecycle.projection = projection;
+
+  async function stop() {
+    const pending = lifecycle.inFlight;
+    const pendingProjection = lifecycle.projectionInFlight;
+    detachLifecycle();
+    if (pending) {
+      try { await pending; } catch {}
+    }
+    if (pendingProjection) {
+      try { await pendingProjection; } catch {}
+    }
+  }
+
+  return { stop };
+}
+
+export function recorderHealth({ projectRoot } = {}) {
+  const key = isNonEmptyString(projectRoot)
+    ? path.resolve(projectRoot)
+    : lastProjectRoot;
+  const base = key && recorders.get(key) ? recorders.get(key).health() : makeDisabledRecorder().health();
+  const dropped = (base.dropped_stage_off || 0)
+    + (base.dropped_invalid || 0)
+    + (base.dropped_sanitized || 0)
+    + (base.dropped_oldest || 0)
+    + (base.dropped_write || 0)
+    + (base.dropped_sampled || 0);
+  return {
+    ...base,
+    emitted: base.accepted || 0,
+    dropped,
+    flushed: base.written || 0,
+    running: lifecycle.running === true,
+    project_root: key,
+    // Async handle for awaiting a lifecycle-triggered drain (tests, CLI
+    // status right after collect) — lifecycle state, not a counter.
+    in_flight: lifecycle.inFlight,
+  };
+}
+
+/** Test/reset seam: detach every handle and drop all memoized recorders. */
+export function resetForTests() {
+  detachLifecycle();
+  lifecycle.inFlight = null;
+  recorders.clear();
+  disabledRecorder = null;
+  lastProjectRoot = null;
+}

package/src/core/observability/emit/recorder.js

@@ -6,11 +6,11 @@
  *     → { emit, startSpan, endSpan, flush, health }
  *
  * Pipeline per emit(): stage gate → fill missing envelope fields →
- * validateSemanticRecord → sanitizeObserved → bounded in-memory queue.
- * Nothing reaches disk from emit(); flush() drains the queue through the
- * segment store's appendRecord (TASK-006) — the recorder composes the
- * writer, it never reimplements writes.
- *
+ * validateSemanticRecord → sanitizeObserved → sampling decider → bounded
+ * in-memory queue. Nothing reaches disk from emit(); flush() drains the
+ * queue through the segment store's appendRecord (TASK-006) — the recorder
+ * composes the writer, it never reimplements writes.
+
  * Guarantees (DF-FR04):
  *   - emit() is synchronous, non-blocking, and never throws — every failure
  *     is a typed { status: 'dropped', reason } plus a health() counter.
@@ -25,6 +25,22 @@
  *   - No LLM, no sync fs, no daemon. Stage is read live per emit, so
  *     config.observability.stage = 'off' is an immediate kill switch.
  *
+ * DF2-FR02: when `observability.sampling` resolves to a policy (see
+ * emit/config.js), every kept record is stamped
+ * `sampling:{policy_version, rate}` with its EFFECTIVE keep rate and a
+ * seeded-bucket decider evicts records pre-queue:
+ * `bucket = murmurHash(record_id, seed) % 10000`, kept iff
+ * `bucket < round(rate * 10000)` — same record_id + seed always lands the
+ * same decision, and `samplingSeed` is injectable for tests. `critical`
+ * importance is never sampled (effective rate 1 regardless of config).
+ * Sampled drops never emit per-record telemetry on the hot path: they
+ * accumulate into `pending_sampled` and flush() enqueues ONE
+ * telemetry.dropped{reason_code:'SAMPLED_OUT', dropped_count} aggregate per
+ * flush; a malformed config latch surfaces once per boot as
+ * telemetry.dropped{reason_code:'CONFIG_INVALID'}. Self-records are built
+ * through the same validate/sanitize path but are never recursively
+ * sampled.
+ *
  * DF-FR08: model.completed/model.failed records emitted without
  * payload.resource are stamped { value: null, source: 'UNKNOWN' } —
  * host-blind stays explicitly unknown, never 0, never invented.
@@ -37,9 +53,11 @@ import { sanitizeObserved } from '../privacy/sanitizeObserved.js';
 import { SEMANTIC_REGISTRY } from '../schema/registry.js';
 import { SCHEMA_VERSION } from '../schema/constants.js';
 import { appendRecord } from '../segments/retention.js';
-import { resolveStage } from './config.js';
+import { resolveStage, resolveSampling, samplingConfigInvalid } from './config.js';
 
 const DEFAULT_QUEUE_SIZE = 1024;
+const SAMPLING_BUCKETS = 10000;
+const SAMPLING_SEED = 0;
 const SPAN_STATUSES = new Set(['completed', 'failed', 'blocked']);
 // Semantic names whose payload carries typed resource usage (DF-FR08).
 const RESOURCE_SEMANTICS = new Set(['model.completed', 'model.failed']);
@@ -48,6 +66,47 @@ function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
+// DF2-FR02 decider: murmur-like seeded hash of record_id → bucket in
+// [0, SAMPLING_BUCKETS). Pure integer math — no allocation, no IO, and the
+// same (record_id, seed) always yields the same bucket across hosts so a
+// sampling run is replayable from the recorded ids alone.
+function samplingBucket(recordId, seed) {
+  let h = (seed >>> 0) ^ recordId.length;
+  for (let i = 0; i < recordId.length; i++) {
+    h = Math.imul(h ^ recordId.charCodeAt(i), 0x5bd1e995);
+    h ^= h >>> 13;
+  }
+  h ^= h >>> 15;
+  h = Math.imul(h, 0x5bd1e995);
+  h ^= h >>> 15;
+  return (h >>> 0) % SAMPLING_BUCKETS;
+}
+
+// 'critical' is never sampled (DF2-FR02): effective keep rate is 1 even
+// when the policy carries rates.critical below 1 — a misconfigured
+// critical rate can never shed the records kept for crash diagnosis.
+function effectiveSamplingRate(policy, importance) {
+  if (importance === 'critical') return 1;
+  const rate = policy.rates[importance];
+  return typeof rate === 'number' ? rate : 1;
+}
+
+function keptBySampling(recordId, rate, seed) {
+  if (rate >= 1) return true;
+  if (rate <= 0) return false;
+  if (typeof recordId !== 'string' || recordId.length === 0) return true;
+  return samplingBucket(recordId, seed) < Math.round(rate * SAMPLING_BUCKETS);
+}
+
+function stampSampling(candidate, policy) {
+  if (policy !== null && isPlainObject(candidate)) {
+    candidate.sampling = {
+      policy_version: policy.policy_version,
+      rate: effectiveSamplingRate(policy, candidate.importance),
+    };
+  }
+}
+
 function defaultClock() {
   return {
     nowMs: () => Date.now(),
@@ -56,10 +115,11 @@ function defaultClock() {
   };
 }
 
-export function createRecorder({ root, config, queueSize, writer, clock } = {}) {
+export function createRecorder({ root, config, queueSize, writer, clock, samplingSeed } = {}) {
   const bound = Number.isInteger(queueSize) && queueSize > 0 ? queueSize : DEFAULT_QUEUE_SIZE;
   const write = typeof writer === 'function' ? writer : (record) => appendRecord(root, record);
   const time = clock && typeof clock.nowNs === 'function' ? clock : defaultClock();
+  const seed = Number.isFinite(samplingSeed) ? samplingSeed >>> 0 : SAMPLING_SEED;
 
   const state = {
     queue: [],
@@ -76,6 +136,11 @@ export function createRecorder({ root, config, queueSize, writer, clock } = {})
     dropped_write: 0,
     write_failures: 0,
     invalid_spans: 0,
+    dropped_sampled: 0,
+    pending_sampled: 0,
+    config_invalid_reported: false,
+    flushes: 0,
+    last_flush: null,
     last_error: null,
   };
 
@@ -120,7 +185,9 @@ export function createRecorder({ root, config, queueSize, writer, clock } = {})
         state.dropped_stage_off += 1;
         return { status: 'dropped', reason: 'stage-off' };
       }
+      const policy = resolveSampling(config);
       const candidate = isPlainObject(record) ? fillEnvelope(record) : record;
+      stampSampling(candidate, policy);
       const validation = validateSemanticRecord(candidate);
       if (!validation.ok) {
         state.dropped_invalid += 1;
@@ -131,6 +198,11 @@ export function createRecorder({ root, config, queueSize, writer, clock } = {})
         state.dropped_sanitized += 1;
         return { status: 'dropped', reason: 'sanitize-rejected' };
       }
+      if (policy !== null && !keptBySampling(candidate.record_id, candidate.sampling.rate, seed)) {
+        state.dropped_sampled += 1;
+        state.pending_sampled += 1;
+        return { status: 'dropped', reason: 'sampled-out' };
+      }
       let evicted = false;
       if (state.queue.length >= bound) {
         state.queue.shift();
@@ -148,6 +220,25 @@ export function createRecorder({ root, config, queueSize, writer, clock } = {})
     }
   }
 
+  // Recorder-originated telemetry (drop aggregates, config faults) goes
+  // through the same fill/validate/sanitize path as caller records but
+  // bypasses the decider — a self-record is never recursively sampled. On a
+  // full queue the oldest record is evicted for it, same policy as emit().
+  function queueSelfRecord(record, policy) {
+    const candidate = fillEnvelope(record);
+    stampSampling(candidate, policy);
+    const validation = validateSemanticRecord(candidate);
+    if (!validation.ok) return false;
+    const clean = sanitizeObserved(candidate);
+    if (!clean.ok) return false;
+    if (state.queue.length >= bound) {
+      state.queue.shift();
+      state.dropped_oldest += 1;
+    }
+    state.queue.push(clean.record);
+    return true;
+  }
+
   function startSpan(traceId, operation) {
     const trace_id = typeof traceId === 'string' && traceId.length > 0
       ? traceId
@@ -198,7 +289,11 @@ export function createRecorder({ root, config, queueSize, writer, clock } = {})
       .then(() => write(record))
       .then((r) => (r && r.ok ? 'ok' : (r && r.reason) || 'write-failed'))
       .catch(() => 'write-failed');
-    if (!Number.isFinite(budgetMs) || budgetMs <= 0) return 'deadline';
+    if (!Number.isFinite(budgetMs) || budgetMs <= 0) {
+      // No deadline (Infinity) → await the write unbounded; a non-positive
+      // budget reports deadline without starting another write race.
+      return Number.isFinite(budgetMs) ? 'deadline' : writePromise;
+    }
     let timer;
     try {
       return await Promise.race([
@@ -266,10 +361,36 @@ export function createRecorder({ root, config, queueSize, writer, clock } = {})
         /* pump() never rejects; belt-and-suspenders */
       }
     }
+    // Drain pending self-telemetry into the same flush: ONE aggregate per
+    // reason — sampled drops are rate-limited to a single queued record per
+    // flush (never recursively sampled), and the malformed-config latch is
+    // reported once per boot. The aggregate record itself stays queued if
+    // its write fails, so the count is never silently lost before landing.
+    const policyAtFlush = resolveSampling(config);
+    if (state.pending_sampled > 0) {
+      const count = state.pending_sampled;
+      if (queueSelfRecord({
+        semantic_name: 'telemetry.dropped',
+        payload: { reason_code: 'SAMPLED_OUT', dropped_count: count },
+      }, policyAtFlush)) {
+        state.pending_sampled = 0;
+      }
+    }
+    if (samplingConfigInvalid() && !state.config_invalid_reported) {
+      if (queueSelfRecord({
+        semantic_name: 'telemetry.dropped',
+        payload: { reason_code: 'CONFIG_INVALID', dropped_count: 1 },
+      }, policyAtFlush)) {
+        state.config_invalid_reported = true;
+      }
+    }
     const run = pump(deadlineMs);
     state.pumping = run;
     try {
-      return await run;
+      const result = await run;
+      state.flushes += 1;
+      state.last_flush = result;
+      return result;
     } finally {
       if (state.pumping === run) state.pumping = null;
     }
@@ -277,6 +398,10 @@ export function createRecorder({ root, config, queueSize, writer, clock } = {})
 
   function health() {
     return {
+      boot_id: state.boot_id,
+      writer_id: state.writer_id,
+      flushes: state.flushes,
+      last_flush: state.last_flush,
       stage: resolveStage(config),
       queue_depth: state.queue.length,
       queue_bound: bound,
@@ -288,6 +413,7 @@ export function createRecorder({ root, config, queueSize, writer, clock } = {})
       dropped_oldest: state.dropped_oldest,
       dropped_write: state.dropped_write,
       write_failures: state.write_failures,
+      dropped_sampled: state.dropped_sampled,
       invalid_spans: state.invalid_spans,
       last_error: state.last_error,
     };