@getstrata/core 2.2.8 → 2.2.10

package/dist/index.js

@@ -687,6 +687,111 @@ var init_deferredModelEvents = __esm(() => {
   deferredModelEvents = createAsyncContextStore("@getstrata/deferredModelEvents");
 });
 
+// ../../src/core/database/acquisitionMetrics.ts
+function createTransactionAcquisitionMetrics() {
+  const state = {
+    inflight: 0,
+    outcomes: outcomes.map((outcome) => ({
+      outcome,
+      count: 0,
+      sumSeconds: 0,
+      buckets: ACQUISITION_BUCKETS_SECONDS.map(() => 0)
+    }))
+  };
+  const metrics = {
+    [metricsBrand]: true,
+    snapshot: () => ({
+      inflight: state.inflight,
+      outcomes: state.outcomes.map((histogram) => ({
+        ...histogram,
+        buckets: [...histogram.buckets]
+      }))
+    })
+  };
+  states.set(metrics, state);
+  return metrics;
+}
+async function observeTransactionAcquisition(metrics, acquire, signal) {
+  const state = states.get(metrics);
+  if (!state)
+    throw new TypeError("Transaction acquisition metrics must be created by the framework factory.");
+  const started = performance.now();
+  state.inflight++;
+  let outcome = "acquired";
+  try {
+    return await acquire();
+  } catch (error) {
+    outcome = signal?.aborted ? "aborted" : "failed";
+    throw error;
+  } finally {
+    state.inflight--;
+    const elapsed = Math.max(0, performance.now() - started) / 1000;
+    const histogram = state.outcomes[outcomes.indexOf(outcome)];
+    if (histogram) {
+      histogram.count++;
+      histogram.sumSeconds += elapsed;
+      for (let index = 0;index < ACQUISITION_BUCKETS_SECONDS.length; index++) {
+        const bound = ACQUISITION_BUCKETS_SECONDS[index];
+        if (bound !== undefined && elapsed <= bound)
+          histogram.buckets[index] = (histogram.buckets[index] ?? 0) + 1;
+      }
+    }
+  }
+}
+function renderTransactionAcquisitionMetrics(snapshot) {
+  const invalid = () => new TypeError("Invalid transaction acquisition metrics.");
+  if (!Number.isSafeInteger(snapshot.inflight) || snapshot.inflight < 0 || snapshot.outcomes.length !== outcomes.length)
+    throw invalid();
+  const name = "strata_database_transaction_acquisition_duration_seconds";
+  const lines = [
+    "# HELP strata_database_acquisition_collector_success Whether transaction acquisition observation succeeded.",
+    "# TYPE strata_database_acquisition_collector_success gauge",
+    "strata_database_acquisition_collector_success 1",
+    "# HELP strata_database_transaction_acquisition_inflight Native transaction checkouts awaiting settlement in this process.",
+    "# TYPE strata_database_transaction_acquisition_inflight gauge",
+    `strata_database_transaction_acquisition_inflight ${snapshot.inflight}`,
+    `# HELP ${name} Native checkout duration, including pool wait and connection establishment, for explicitly observed transactions.`,
+    `# TYPE ${name} histogram`
+  ];
+  for (let i = 0;i < outcomes.length; i++) {
+    const histogram = snapshot.outcomes[i];
+    if (!histogram || histogram.outcome !== outcomes[i] || !Number.isSafeInteger(histogram.count) || histogram.count < 0 || !Number.isFinite(histogram.sumSeconds) || histogram.sumSeconds < 0 || histogram.buckets.length !== ACQUISITION_BUCKETS_SECONDS.length)
+      throw invalid();
+    let previous = 0;
+    for (let index = 0;index < ACQUISITION_BUCKETS_SECONDS.length; index++) {
+      const value = histogram.buckets[index];
+      if (value === undefined || !Number.isSafeInteger(value) || value < previous || value > histogram.count)
+        throw invalid();
+      previous = value;
+      lines.push(`${name}_bucket{outcome="${histogram.outcome}",le="${ACQUISITION_BUCKETS_SECONDS[index]}"} ${value}`);
+    }
+    lines.push(`${name}_bucket{outcome="${histogram.outcome}",le="+Inf"} ${histogram.count}`, `${name}_count{outcome="${histogram.outcome}"} ${histogram.count}`, `${name}_sum{outcome="${histogram.outcome}"} ${histogram.sumSeconds}`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+var ACQUISITION_BUCKETS_SECONDS, outcomes, metricsBrand, states;
+var init_acquisitionMetrics = __esm(() => {
+  ACQUISITION_BUCKETS_SECONDS = [
+    0.001,
+    0.005,
+    0.01,
+    0.025,
+    0.05,
+    0.1,
+    0.25,
+    0.5,
+    1,
+    2.5,
+    5,
+    10
+  ];
+  outcomes = ["acquired", "failed", "aborted"];
+  metricsBrand = Symbol("transaction acquisition metrics");
+  states = new WeakMap;
+});
+
 // ../../src/core/database/connection.ts
 function createDatabaseConnection(source) {
   return {
@@ -730,28 +835,51 @@ async function runInSavepoint(connection, operation) {
 function supportsTransactions(connection) {
   return typeof connection.begin === "function";
 }
-async function runInTransaction(operation) {
+async function runInTransaction(operation, options = {}) {
+  const signal = options.acquisitionSignal;
+  signal?.throwIfAborted();
+  const admittedOperation = (connection) => {
+    signal?.throwIfAborted();
+    return operation(connection);
+  };
   const pool = resolveRepositoryConnection();
   if (hasActiveDatabaseConnection()) {
-    return await runInSavepoint(getActiveDatabaseConnection(pool), operation);
+    return await runInSavepoint(getActiveDatabaseConnection(pool), admittedOperation);
   }
   if (!supportsTransactions(pool)) {
     throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
   }
   return await settleTransaction(() => runWithDeferredModelEvents(async () => {
-    return await pool.begin(async (transaction) => {
-      return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(createDatabaseConnection(transaction))))));
-    });
+    let reserved;
+    if (signal || options.acquisitionMetrics) {
+      if (!pool.reserve)
+        throw new Error(signal ? "Active database connection does not support cancellable transaction acquisition." : "Active database connection does not support observable transaction acquisition.");
+      const reserve = pool.reserve.bind(pool);
+      reserved = options.acquisitionMetrics ? await observeTransactionAcquisition(options.acquisitionMetrics, () => reserve({ signal }), signal) : await reserve({ signal });
+    }
+    const connection = reserved ?? pool;
+    try {
+      signal?.throwIfAborted();
+      if (!supportsTransactions(connection))
+        throw new Error("Reserved database connection does not support transactions.");
+      return await connection.begin(async (transaction) => {
+        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(createDatabaseConnection(transaction))))));
+      });
+    } finally {
+      await reserved?.release();
+    }
   }));
 }
 var transactionFrame, outerFrames;
 var init_transaction = __esm(() => {
   init_deferredModelEvents();
   init_asyncContextStore();
+  init_acquisitionMetrics();
   init_connection();
   init_connectionContext();
   init_repositoryConnection();
   init_transactionControl();
+  init_acquisitionMetrics();
   transactionFrame = createAsyncContextStore("@getstrata/transactionFrame");
   outerFrames = new WeakMap;
 });
@@ -4106,6 +4234,10 @@ var CACHE_TAGS = {
   careers: "careers",
   offers: "offers"
 };
+
+// ../../src/framework/public-api.ts
+init_acquisitionMetrics();
+
 // ../../src/core/database/baseRepository.ts
 init_eventBus();
 
@@ -9164,10 +9296,75 @@ init_databaseTenantContext();
 init_tenantContext();
 init_tenantDatabaseScope();
 
-// ../../src/core/events/outbox/metrics.ts
+// ../../src/core/database/postgresReadOnlyCollector.ts
+init_connectionContext();
 init_dialect();
 init_repositoryConnection();
 init_transaction();
+function createPostgresReadOnlyCollector(name, timeoutMs, collect) {
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 5000)
+    throw new TypeError(`${name} timeout must be between 1 and 5000 milliseconds.`);
+  let active;
+  let closed = false;
+  return {
+    async collect() {
+      if (closed)
+        throw new Error(`${name} collector is closed.`);
+      if (hasActiveTransaction() || hasActiveDatabaseConnection())
+        throw new Error(`${name} require an independent transaction.`);
+      if (currentSqlDialect().driver !== "pgsql")
+        throw new Error(`${name} currently require Postgres.`);
+      if (active)
+        throw new Error(`${name} collection is still settling.`);
+      const deadline = performance.now() + timeoutMs;
+      let expired = false;
+      const acquisition = new AbortController;
+      let timer;
+      const remaining = () => {
+        const value = Math.floor(deadline - performance.now());
+        if (expired || value < 1)
+          throw new Error(`${name} collection timed out.`);
+        return value;
+      };
+      const work = runInTransaction(async () => {
+        await repositoryConnection.unsafe("SELECT set_config('statement_timeout', $1, true)", [`${remaining()}ms`]);
+        await repositoryConnection.unsafe("SET TRANSACTION READ ONLY");
+        remaining();
+        const result = await collect(remaining);
+        remaining();
+        return result;
+      }, { acquisitionSignal: acquisition.signal });
+      active = work;
+      work.finally(() => {
+        if (active === work)
+          active = undefined;
+      }).catch(() => {});
+      try {
+        return await Promise.race([
+          work,
+          new Promise((_, reject) => {
+            timer = setTimeout(() => {
+              expired = true;
+              const error = new Error(`${name} collection timed out.`);
+              acquisition.abort(error);
+              reject(error);
+            }, timeoutMs);
+          })
+        ]);
+      } finally {
+        if (timer !== undefined)
+          clearTimeout(timer);
+      }
+    },
+    async close() {
+      closed = true;
+      await active?.catch(() => {});
+    }
+  };
+}
+
+// ../../src/core/events/outbox/metrics.ts
+init_repositoryConnection();
 init_databaseTenantContext();
 var specifications = [
   { state: "pending_due", status: "pending", column: "available_at", predicate: "<=", age: true },
@@ -9217,81 +9414,29 @@ UNION ALL
 function createOutboxMetricsCollector(options = {}) {
   const timeoutMs = options.timeoutMs ?? 1000;
   const sampleLimit = options.sampleLimit ?? 500;
-  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 5000)
-    throw new TypeError("Outbox metrics timeout must be between 1 and 5000 milliseconds.");
   if (!Number.isSafeInteger(sampleLimit) || sampleLimit < 1 || sampleLimit > 1000)
     throw new TypeError("Outbox metrics sample limit must be between 1 and 1000.");
-  let active;
-  let closed = false;
-  return {
-    async collect() {
-      if (closed)
-        throw new Error("Outbox metrics collector is closed.");
-      if (hasActiveTransaction())
-        throw new Error("Outbox metrics require an independent transaction.");
-      if (currentSqlDialect().driver !== "pgsql")
-        throw new Error("Outbox metrics currently require Postgres.");
-      if (active)
-        throw new Error("Outbox metrics collection is still settling.");
-      const deadline = performance.now() + timeoutMs;
-      let expired = false;
-      let timer;
-      const remaining = () => {
-        const value = Math.floor(deadline - performance.now());
-        if (expired || value < 1)
-          throw new Error("Outbox metrics collection timed out.");
-        return value;
+  return createPostgresReadOnlyCollector("Outbox metrics", timeoutMs, (remaining) => runWithMigrationBypass(async () => {
+    remaining();
+    const rows = await repositoryConnection.unsafe(snapshotQuery, [sampleLimit + 1]);
+    remaining();
+    if (rows.length !== specifications.length)
+      throw new Error("Invalid outbox metrics response.");
+    const states = specifications.map((spec) => {
+      const row = rows.find((value) => value.state === spec.state);
+      const count = Number(row?.count);
+      const lateness = row?.lateness_ms == null ? null : Number(row.lateness_ms);
+      if (!Number.isSafeInteger(count) || count < 0 || count > sampleLimit + 1 || spec.age && (lateness === null || !Number.isFinite(lateness) || lateness < 0))
+        throw new Error("Invalid outbox metrics values.");
+      return {
+        state: spec.state,
+        count: Math.min(count, sampleLimit),
+        capped: count > sampleLimit,
+        actionableLatenessSeconds: lateness === null ? null : lateness / 1000
       };
-      const work = runInTransaction(async () => {
-        await repositoryConnection.unsafe("SELECT set_config('statement_timeout', $1, true)", [`${remaining()}ms`]);
-        await repositoryConnection.unsafe("SET TRANSACTION READ ONLY");
-        return runWithMigrationBypass(async () => {
-          remaining();
-          const rows = await repositoryConnection.unsafe(snapshotQuery, [sampleLimit + 1]);
-          remaining();
-          if (rows.length !== specifications.length)
-            throw new Error("Invalid outbox metrics response.");
-          const states = specifications.map((spec) => {
-            const row = rows.find((value) => value.state === spec.state);
-            const count = Number(row?.count);
-            const lateness = row?.lateness_ms == null ? null : Number(row.lateness_ms);
-            if (!Number.isSafeInteger(count) || count < 0 || count > sampleLimit + 1 || spec.age && (lateness === null || !Number.isFinite(lateness) || lateness < 0))
-              throw new Error("Invalid outbox metrics values.");
-            return {
-              state: spec.state,
-              count: Math.min(count, sampleLimit),
-              capped: count > sampleLimit,
-              actionableLatenessSeconds: lateness === null ? null : lateness / 1000
-            };
-          });
-          return { sampleLimit, states };
-        });
-      });
-      active = work;
-      work.finally(() => {
-        if (active === work)
-          active = undefined;
-      }).catch(() => {});
-      try {
-        return await Promise.race([
-          work,
-          new Promise((_, reject) => {
-            timer = setTimeout(() => {
-              expired = true;
-              reject(new Error("Outbox metrics collection timed out."));
-            }, timeoutMs);
-          })
-        ]);
-      } finally {
-        if (timer !== undefined)
-          clearTimeout(timer);
-      }
-    },
-    async close() {
-      closed = true;
-      await active?.catch(() => {});
-    }
-  };
+    });
+    return { sampleLimit, states };
+  }));
 }
 function renderOutboxMetrics(snapshot) {
   if (!Number.isSafeInteger(snapshot.sampleLimit) || snapshot.sampleLimit < 1 || snapshot.sampleLimit > 1000 || snapshot.states.length !== specifications.length)
@@ -12856,6 +13001,67 @@ class Notification {
     return null;
   }
 }
+// ../../src/core/queue/failedJobMetrics.ts
+init_repositoryConnection();
+
+// ../../src/core/queue/failedJobTable.ts
+var failedJobTable = defineTable({
+  name: "failed_job",
+  primaryKey: "id",
+  columns: ["id", "job_name", "job_id", "payload", "exception", "failed_at"],
+  defaultOrderBy: { column: "failed_at", direction: "DESC" }
+});
+
+// ../../src/core/queue/failedJobRepository.ts
+class FailedJobRepository extends BaseRepository {
+  constructor() {
+    super(failedJobTable);
+  }
+}
+var failedJobRepository_default = FailedJobRepository;
+
+// ../../src/core/queue/failedJobMetrics.ts
+var schemaQuery = `SELECT c.relkind = 'r' AND c.relpersistence = 'p' AND NOT c.relrowsecurity AND EXISTS (
+  SELECT 1 FROM pg_index i JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = i.indkey[0]
+  WHERE i.indrelid = c.oid AND i.indisprimary AND i.indisvalid AND i.indisready
+    AND i.indnkeyatts = 1 AND a.attname = 'id' AND NOT a.attisdropped
+    AND a.atttypid IN ('int2'::regtype, 'int4'::regtype, 'int8'::regtype)
+) AS supported FROM pg_class c WHERE c.oid = 'failed_job'::regclass`;
+function createFailedJobMetricsCollector(options = {}) {
+  const sampleLimit = options.sampleLimit ?? 500;
+  if (!Number.isSafeInteger(sampleLimit) || sampleLimit < 1 || sampleLimit > 1000)
+    throw new TypeError("Failed-job metrics sample limit must be between 1 and 1000.");
+  const repository = new failedJobRepository_default;
+  return createPostgresReadOnlyCollector("Failed-job metrics", options.timeoutMs ?? 1000, async (remaining) => {
+    await repositoryConnection.unsafe('LOCK TABLE "failed_job" IN ACCESS SHARE MODE');
+    const schema = await repositoryConnection.unsafe(schemaQuery);
+    if (schema.length !== 1 || schema[0]?.supported !== true)
+      throw new Error("Failed-job metrics require the standard global table with an ID primary key and no RLS.");
+    remaining();
+    const rows = await repository.query().orderBy({ column: "id", direction: "ASC" }).project(["id"], sampleLimit + 1);
+    if (rows.length > sampleLimit + 1 || rows.some((row) => row.id == null))
+      throw new Error("Invalid failed-job metrics response.");
+    return {
+      sampleLimit,
+      count: Math.min(rows.length, sampleLimit),
+      capped: rows.length > sampleLimit
+    };
+  });
+}
+function renderFailedJobMetrics(snapshot) {
+  if (!Number.isSafeInteger(snapshot.sampleLimit) || snapshot.sampleLimit < 1 || snapshot.sampleLimit > 1000 || !Number.isSafeInteger(snapshot.count) || snapshot.count < 0 || snapshot.count > snapshot.sampleLimit || typeof snapshot.capped !== "boolean" || snapshot.capped && snapshot.count !== snapshot.sampleLimit)
+    throw new TypeError("Invalid failed-job metrics snapshot.");
+  return `# HELP strata_queue_failed_job_collector_success Whether failed-job collection succeeded.
+# TYPE strata_queue_failed_job_collector_success gauge
+strata_queue_failed_job_collector_success 1
+# HELP strata_queue_failed_jobs_sample Capped retained failed-job count; a lower bound when capped.
+# TYPE strata_queue_failed_jobs_sample gauge
+strata_queue_failed_jobs_sample ${snapshot.count}
+# HELP strata_queue_failed_jobs_sample_capped Whether the failed-job sample is truncated.
+# TYPE strata_queue_failed_jobs_sample_capped gauge
+strata_queue_failed_jobs_sample_capped ${Number(snapshot.capped)}
+`;
+}
 // ../../src/core/queue/jobRegistry.ts
 class JobRegistry {
   factories = new Map;
@@ -12950,22 +13156,6 @@ class AsyncQueue {
 function createQueue(driver) {
   return driver === "async" ? new AsyncQueue : new SyncQueue;
 }
-// ../../src/core/queue/failedJobTable.ts
-var failedJobTable = defineTable({
-  name: "failed_job",
-  primaryKey: "id",
-  columns: ["id", "job_name", "job_id", "payload", "exception", "failed_at"],
-  defaultOrderBy: { column: "failed_at", direction: "DESC" }
-});
-
-// ../../src/core/queue/failedJobRepository.ts
-class FailedJobRepository extends BaseRepository {
-  constructor() {
-    super(failedJobTable);
-  }
-}
-var failedJobRepository_default = FailedJobRepository;
-
 // ../../src/core/queue/failedJobService.ts
 class FailedJobService {
   repository;
@@ -14668,6 +14858,171 @@ function createTenantMiddleware(options = {}) {
     }
   };
 }
+// ../../src/core/tracing/health.ts
+import {
+  createNoopMeter
+} from "@opentelemetry/api";
+import { ExportResultCode } from "@opentelemetry/core";
+function observeExportDeadline(state, timeoutMillis) {
+  const deadline = setTimeout(() => {
+    state.exportDeadlineExceededBatches++;
+  }, timeoutMillis);
+  deadline.unref();
+  return deadline;
+}
+function createTracingHealth(enabled, exporterConfigured, timeoutMillis) {
+  const state = {
+    enabled,
+    exporterConfigured,
+    active: true,
+    queueSize: null,
+    queueCapacity: null,
+    droppedSpans: 0,
+    exportedBatches: 0,
+    failedBatches: 0,
+    exportedSpans: 0,
+    failedSpans: 0,
+    exportDeadlineExceededBatches: 0,
+    flushFailures: 0,
+    shutdownFailures: 0
+  };
+  let exportQueueFullSpans = 0;
+  let queueCallback;
+  const noop = createNoopMeter();
+  const meter = {
+    createGauge: noop.createGauge.bind(noop),
+    createHistogram: noop.createHistogram.bind(noop),
+    createObservableGauge: noop.createObservableGauge.bind(noop),
+    createObservableCounter: noop.createObservableCounter.bind(noop),
+    addBatchObservableCallback: noop.addBatchObservableCallback.bind(noop),
+    removeBatchObservableCallback: noop.removeBatchObservableCallback.bind(noop),
+    createCounter(name, options) {
+      if (name !== "otel.sdk.processor.span.processed")
+        return noop.createCounter(name, options);
+      return {
+        add(value, attributes) {
+          if (attributes?.["error.type"] === "queue_full")
+            state.droppedSpans += value;
+        }
+      };
+    },
+    createUpDownCounter(name, options) {
+      if (name !== "otel.sdk.processor.span.queue.capacity")
+        return noop.createUpDownCounter(name, options);
+      return {
+        add(value) {
+          state.queueCapacity = (state.queueCapacity ?? 0) + value;
+        }
+      };
+    },
+    createObservableUpDownCounter(name, options) {
+      if (name !== "otel.sdk.processor.span.queue.size")
+        return noop.createObservableUpDownCounter(name, options);
+      return {
+        addCallback(callback) {
+          queueCallback = callback;
+        },
+        removeCallback(callback) {
+          if (queueCallback === callback)
+            queueCallback = undefined;
+        }
+      };
+    }
+  };
+  const meterProvider = { getMeter: () => meter };
+  return {
+    state,
+    meterProvider,
+    snapshot() {
+      let queueSize = null;
+      queueCallback?.({
+        observe(value) {
+          queueSize = value;
+        }
+      });
+      return {
+        ...state,
+        queueSize,
+        droppedSpans: Math.max(0, state.droppedSpans - exportQueueFullSpans)
+      };
+    },
+    wrap(exporter) {
+      return {
+        export(spans, callback) {
+          const count = spans.length;
+          let completed = false;
+          const deadline = observeExportDeadline(state, timeoutMillis);
+          const finish = (success) => {
+            completed = true;
+            clearTimeout(deadline);
+            if (success) {
+              state.exportedBatches++;
+              state.exportedSpans += count;
+            } else {
+              state.failedBatches++;
+              state.failedSpans += count;
+            }
+          };
+          try {
+            exporter.export(spans, (result) => {
+              if (completed)
+                return;
+              finish(result.code === ExportResultCode.SUCCESS);
+              if (result.error?.name === "queue_full")
+                exportQueueFullSpans += count;
+              callback(result);
+            });
+          } catch (error) {
+            if (!completed)
+              finish(false);
+            throw error;
+          }
+        },
+        shutdown: () => exporter.shutdown(),
+        ...exporter.forceFlush ? { forceFlush: exporter.forceFlush.bind(exporter) } : {}
+      };
+    }
+  };
+}
+function renderTracingMetrics(snapshot) {
+  for (const key of ["enabled", "exporterConfigured", "active"])
+    if (typeof snapshot[key] !== "boolean")
+      throw new TypeError("Invalid tracing metrics.");
+  const values = {
+    strata_tracing_enabled: Number(snapshot.enabled),
+    strata_tracing_exporter_configured: Number(snapshot.exporterConfigured),
+    strata_tracing_active: Number(snapshot.active),
+    strata_tracing_queue_size: snapshot.queueSize,
+    strata_tracing_queue_capacity: snapshot.queueCapacity,
+    strata_tracing_dropped_spans_total: snapshot.droppedSpans,
+    strata_tracing_exported_batches_total: snapshot.exportedBatches,
+    strata_tracing_failed_batches_total: snapshot.failedBatches,
+    strata_tracing_exported_spans_total: snapshot.exportedSpans,
+    strata_tracing_failed_spans_total: snapshot.failedSpans,
+    strata_tracing_export_deadline_exceeded_batches_total: snapshot.exportDeadlineExceededBatches,
+    strata_tracing_flush_failures_total: snapshot.flushFailures,
+    strata_tracing_shutdown_failures_total: snapshot.shutdownFailures
+  };
+  let output = `# HELP strata_tracing_collector_success Whether tracing observation succeeded.
+# TYPE strata_tracing_collector_success gauge
+strata_tracing_collector_success 1
+`;
+  for (const [name, value] of Object.entries(values)) {
+    if (value === null) {
+      if (name === "strata_tracing_queue_size" || name === "strata_tracing_queue_capacity")
+        continue;
+      throw new TypeError("Invalid tracing metrics.");
+    }
+    if (!Number.isSafeInteger(value) || value < 0)
+      throw new TypeError("Invalid tracing metrics.");
+    const type = name.endsWith("_total") ? "counter" : "gauge";
+    output += `# HELP ${name} Process-local tracing ${name.slice(15).replaceAll("_", " ")}.
+# TYPE ${name} ${type}
+${name} ${value}
+`;
+  }
+  return output;
+}
 // ../../src/core/tracing/traceContext.ts
 init_asyncContextStore();
 var traceContextStorage = createAsyncContextStore("@getstrata/traceContext");
@@ -14686,10 +15041,10 @@ import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-ho
 import { W3CTraceContextPropagator } from "@opentelemetry/core";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace";
 import {
   AlwaysOffSampler,
   AlwaysOnSampler,
-  BatchSpanProcessor,
   ParentBasedSampler,
   TraceIdRatioBasedSampler
 } from "@opentelemetry/sdk-trace-base";
@@ -14743,11 +15098,14 @@ function createTracingRuntime(options = {}) {
       throw new TypeError("Invalid tracing collector endpoint.");
   }
   const exporter = disabled ? undefined : options.exporter ?? (endpoint ? new OTLPTraceExporter({ url: endpoint, timeoutMillis: timeout, concurrencyLimit: 1 }) : undefined);
+  const health = createTracingHealth(!disabled, exporter !== undefined, timeout);
   const provider = new NodeTracerProvider({
     resource: resourceFromAttributes({ "service.name": options.serviceName ?? otelServiceName() }),
     sampler,
     spanProcessors: exporter ? [
-      new BatchSpanProcessor(exporter, {
+      new BatchSpanProcessor({
+        exporter: health.wrap(exporter),
+        selfObsMeterProvider: health.meterProvider,
         maxQueueSize: queueSize,
         maxExportBatchSize: batchSize,
         scheduledDelayMillis: delay,
@@ -14767,8 +15125,21 @@ function createTracingRuntime(options = {}) {
     tracer: provider.getTracer("@getstrata/http"),
     propagator: new W3CTraceContextPropagator,
     run: (parent, callback) => context.with(parent, callback),
-    forceFlush: () => provider.forceFlush(),
-    shutdown: () => shutdown ??= provider.shutdown()
+    metrics: () => health.snapshot(),
+    async forceFlush() {
+      try {
+        await provider.forceFlush();
+      } catch (error) {
+        health.state.flushFailures++;
+        throw error;
+      }
+    },
+    shutdown: () => shutdown ??= provider.shutdown().catch((error) => {
+      health.state.shutdownFailures++;
+      throw error;
+    }).finally(() => {
+      health.state.active = false;
+    })
   };
 }
 var runtimeKey = Symbol.for("@getstrata/otel-runtime");
@@ -15388,6 +15759,7 @@ export {
   createCsrfTokenCookie,
   createDatabaseConnection,
   createDatabaseQueryProxy,
+  createFailedJobMetricsCollector,
   createFailedJobService,
   createFlashMiddleware,
   createLoginThrottleMiddleware,
@@ -15424,6 +15796,7 @@ export {
   createTracingMiddleware,
   createTracingRuntime,
   createTrackedJob,
+  createTransactionAcquisitionMetrics,
   createValidateSignatureMiddleware,
   createdResponse,
   currentAuthUser,
@@ -15572,9 +15945,12 @@ export {
   registerModelRepository,
   registerNamedConnection,
   registerShutdownHandler,
+  renderFailedJobMetrics,
   renderKernelErrorChrome,
   renderMarkdownMail,
   renderOutboxMetrics,
+  renderTracingMetrics,
+  renderTransactionAcquisitionMetrics,
   renderWebErrorHtml,
   repositoryConnection,
   requestIdMiddleware,