4runr-os 2.10.49 → 2.10.50

package/apps/gateway/src/metrics/monitoring-detail.ts

@@ -1,162 +1,162 @@
-/**
- * Phase 3: structured snapshots from prom-client metrics for /api/monitoring/metrics/*
- * (no Prometheus text parsing — reads live registry values.)
- */
-
-import {
-  httpRequestTotal,
-  httpRequestErrors,
-  runsCreated,
-  runsStarted,
-  runsCompleted,
-  runsActive,
-  sseConnectionsOpened,
-  sseConnectionsClosed,
-  sseActiveConnections,
-  sseMessagesTotal,
-  dbConnectionsActive,
-  dbConnectionsIdle,
-  redisConnectionsActive,
-} from './index.js';
-
-function sumCounterValues(m: { values: Array<{ value: number }> }): number {
-  return m.values.reduce((s, x) => s + x.value, 0);
-}
-
-function gaugeValue(m: { values: Array<{ value: number }> }): number {
-  return m.values[0]?.value ?? 0;
-}
-
-function isFailedRunStatus(status: string): boolean {
-  const normalized = status.trim().toLowerCase();
-  return [
-    'failed',
-    'failure',
-    'error',
-    'errored',
-    'cancelled',
-    'canceled',
-    'timeout',
-    'timed_out',
-  ].includes(normalized);
-}
-
-export async function getMonitoringHttpPayload(): Promise<Record<string, unknown>> {
-  const req = await httpRequestTotal.get();
-  let totalRequests = 0;
-  const byRoute: Array<{ method: string; route: string; status_code: string; count: number }> =
-    [];
-  for (const x of req.values) {
-    totalRequests += x.value;
-    byRoute.push({
-      method: String(x.labels.method ?? ''),
-      route: String(x.labels.route ?? ''),
-      status_code: String(x.labels.status_code ?? ''),
-      count: x.value,
-    });
-  }
-  byRoute.sort((a, b) => b.count - a.count);
-
-  const err = await httpRequestErrors.get();
-  let totalErrors = 0;
-  const errorsByRoute: Array<{
-    method: string;
-    route: string;
-    error_type: string;
-    count: number;
-  }> = [];
-  for (const x of err.values) {
-    totalErrors += x.value;
-    errorsByRoute.push({
-      method: String(x.labels.method ?? ''),
-      route: String(x.labels.route ?? ''),
-      error_type: String(x.labels.error_type ?? ''),
-      count: x.value,
-    });
-  }
-  errorsByRoute.sort((a, b) => b.count - a.count);
-
-  const errorRate = totalRequests > 0 ? totalErrors / totalRequests : 0;
-
-  return {
-    placeholder: false,
-    summary: {
-      totalRequests,
-      totalErrors,
-      errorRate: Number(errorRate.toFixed(4)),
-    },
-    topRoutes: byRoute.slice(0, 25),
-    errorsByRoute: errorsByRoute.slice(0, 15),
-    timestamp: new Date().toISOString(),
-  };
-}
-
-export async function getMonitoringRunsPayload(): Promise<Record<string, unknown>> {
-  const created = sumCounterValues(await runsCreated.get());
-  const started = sumCounterValues(await runsStarted.get());
-  const completedByStatus = (await runsCompleted.get()).values.map((x) => ({
-    status: String(x.labels.status ?? ''),
-    count: x.value,
-  }));
-  const completed = completedByStatus.reduce((s, x) => s + x.count, 0);
-  const failedByStatus = completedByStatus.filter((x) => isFailedRunStatus(x.status));
-  const active = gaugeValue(await runsActive.get());
-
-  return {
-    placeholder: false,
-    summary: {
-      created,
-      started,
-      completed,
-      failed: failedByStatus.reduce((s, x) => s + x.count, 0),
-      active,
-    },
-    byStatus: completedByStatus,
-    failedStatusLabels: failedByStatus.map((x) => x.status),
-    timestamp: new Date().toISOString(),
-  };
-}
-
-export async function getMonitoringSsePayload(): Promise<Record<string, unknown>> {
-  const opened = sumCounterValues(await sseConnectionsOpened.get());
-  const closed = sumCounterValues(await sseConnectionsClosed.get());
-  const active = gaugeValue(await sseActiveConnections.get());
-  const messages = sumCounterValues(await sseMessagesTotal.get());
-
-  return {
-    placeholder: false,
-    summary: {
-      connectionsOpened: opened,
-      connectionsClosed: closed,
-      activeConnections: active,
-      messagesSent: messages,
-    },
-    timestamp: new Date().toISOString(),
-  };
-}
-
-export async function getDependencyPoolsPayload(): Promise<{
-  database: { active: number; idle: number };
-  redis: { active: number };
-  telemetry: {
-    source: string;
-    bestEffort: boolean;
-    note: string;
-  };
-}> {
-  return {
-    database: {
-      active: gaugeValue(await dbConnectionsActive.get()),
-      idle: gaugeValue(await dbConnectionsIdle.get()),
-    },
-    redis: {
-      active: gaugeValue(await redisConnectionsActive.get()),
-    },
-    telemetry: {
-      source: 'prom-client connection gauges',
-      bestEffort: true,
-      note:
-        'Connection gauges are best-effort instrumentation; zeros can mean the gauges are not being updated, not necessarily that dependencies are disconnected.',
-    },
-  };
-}
+/**
+ * Phase 3: structured snapshots from prom-client metrics for /api/monitoring/metrics/*
+ * (no Prometheus text parsing — reads live registry values.)
+ */
+
+import {
+  httpRequestTotal,
+  httpRequestErrors,
+  runsCreated,
+  runsStarted,
+  runsCompleted,
+  runsActive,
+  sseConnectionsOpened,
+  sseConnectionsClosed,
+  sseActiveConnections,
+  sseMessagesTotal,
+  dbConnectionsActive,
+  dbConnectionsIdle,
+  redisConnectionsActive,
+} from './index.js';
+
+function sumCounterValues(m: { values: Array<{ value: number }> }): number {
+  return m.values.reduce((s, x) => s + x.value, 0);
+}
+
+function gaugeValue(m: { values: Array<{ value: number }> }): number {
+  return m.values[0]?.value ?? 0;
+}
+
+function isFailedRunStatus(status: string): boolean {
+  const normalized = status.trim().toLowerCase();
+  return [
+    'failed',
+    'failure',
+    'error',
+    'errored',
+    'cancelled',
+    'canceled',
+    'timeout',
+    'timed_out',
+  ].includes(normalized);
+}
+
+export async function getMonitoringHttpPayload(): Promise<Record<string, unknown>> {
+  const req = await httpRequestTotal.get();
+  let totalRequests = 0;
+  const byRoute: Array<{ method: string; route: string; status_code: string; count: number }> =
+    [];
+  for (const x of req.values) {
+    totalRequests += x.value;
+    byRoute.push({
+      method: String(x.labels.method ?? ''),
+      route: String(x.labels.route ?? ''),
+      status_code: String(x.labels.status_code ?? ''),
+      count: x.value,
+    });
+  }
+  byRoute.sort((a, b) => b.count - a.count);
+
+  const err = await httpRequestErrors.get();
+  let totalErrors = 0;
+  const errorsByRoute: Array<{
+    method: string;
+    route: string;
+    error_type: string;
+    count: number;
+  }> = [];
+  for (const x of err.values) {
+    totalErrors += x.value;
+    errorsByRoute.push({
+      method: String(x.labels.method ?? ''),
+      route: String(x.labels.route ?? ''),
+      error_type: String(x.labels.error_type ?? ''),
+      count: x.value,
+    });
+  }
+  errorsByRoute.sort((a, b) => b.count - a.count);
+
+  const errorRate = totalRequests > 0 ? totalErrors / totalRequests : 0;
+
+  return {
+    placeholder: false,
+    summary: {
+      totalRequests,
+      totalErrors,
+      errorRate: Number(errorRate.toFixed(4)),
+    },
+    topRoutes: byRoute.slice(0, 25),
+    errorsByRoute: errorsByRoute.slice(0, 15),
+    timestamp: new Date().toISOString(),
+  };
+}
+
+export async function getMonitoringRunsPayload(): Promise<Record<string, unknown>> {
+  const created = sumCounterValues(await runsCreated.get());
+  const started = sumCounterValues(await runsStarted.get());
+  const completedByStatus = (await runsCompleted.get()).values.map((x) => ({
+    status: String(x.labels.status ?? ''),
+    count: x.value,
+  }));
+  const completed = completedByStatus.reduce((s, x) => s + x.count, 0);
+  const failedByStatus = completedByStatus.filter((x) => isFailedRunStatus(x.status));
+  const active = gaugeValue(await runsActive.get());
+
+  return {
+    placeholder: false,
+    summary: {
+      created,
+      started,
+      completed,
+      failed: failedByStatus.reduce((s, x) => s + x.count, 0),
+      active,
+    },
+    byStatus: completedByStatus,
+    failedStatusLabels: failedByStatus.map((x) => x.status),
+    timestamp: new Date().toISOString(),
+  };
+}
+
+export async function getMonitoringSsePayload(): Promise<Record<string, unknown>> {
+  const opened = sumCounterValues(await sseConnectionsOpened.get());
+  const closed = sumCounterValues(await sseConnectionsClosed.get());
+  const active = gaugeValue(await sseActiveConnections.get());
+  const messages = sumCounterValues(await sseMessagesTotal.get());
+
+  return {
+    placeholder: false,
+    summary: {
+      connectionsOpened: opened,
+      connectionsClosed: closed,
+      activeConnections: active,
+      messagesSent: messages,
+    },
+    timestamp: new Date().toISOString(),
+  };
+}
+
+export async function getDependencyPoolsPayload(): Promise<{
+  database: { active: number; idle: number };
+  redis: { active: number };
+  telemetry: {
+    source: string;
+    bestEffort: boolean;
+    note: string;
+  };
+}> {
+  return {
+    database: {
+      active: gaugeValue(await dbConnectionsActive.get()),
+      idle: gaugeValue(await dbConnectionsIdle.get()),
+    },
+    redis: {
+      active: gaugeValue(await redisConnectionsActive.get()),
+    },
+    telemetry: {
+      source: 'prom-client connection gauges',
+      bestEffort: true,
+      note:
+        'Connection gauges are best-effort instrumentation; zeros can mean the gauges are not being updated, not necessarily that dependencies are disconnected.',
+    },
+  };
+}

package/apps/gateway/src/middleware/log-capture.ts

@@ -1,70 +1,70 @@
-/**
- * Log capture middleware for monitoring log buffer
- * Intercepts logger calls and feeds them to the monitoring log buffer
- */
-
-import { addMonitoringLog } from '../routes/monitoring.js';
-
-/**
- * Wrap a logger to capture log entries for monitoring
- * Note: Uses duck typing to avoid strict type checks (compatible with both Logger and memoryLogger)
- */
-export function wrapLoggerForMonitoring(logger: any): any {
-  // Skip if this doesn't look like a standard logger (e.g., memoryLogger)
-  if (!logger || typeof logger.info !== 'function') {
-    return logger;
-  }
-
-  const originalInfo = logger.info.bind(logger);
-  const originalWarn = logger.warn.bind(logger);
-  const originalError = logger.error.bind(logger);
-  const originalDebug = logger.debug?.bind(logger);
-
-  logger.info = (message: string, data?: Record<string, unknown>) => {
-    addMonitoringLog({
-      timestamp: new Date().toISOString(),
-      level: 'info',
-      message,
-      context: logger.context || 'Gateway',
-      ...(data && { data }),
-    });
-    return originalInfo(message, data);
-  };
-
-  logger.warn = (message: string, data?: Record<string, unknown>) => {
-    addMonitoringLog({
-      timestamp: new Date().toISOString(),
-      level: 'warn',
-      message,
-      context: logger.context || 'Gateway',
-      ...(data && { data }),
-    });
-    return originalWarn(message, data);
-  };
-
-  logger.error = (message: string, data?: Record<string, unknown>) => {
-    addMonitoringLog({
-      timestamp: new Date().toISOString(),
-      level: 'error',
-      message,
-      context: logger.context || 'Gateway',
-      ...(data && { data }),
-    });
-    return originalError(message, data);
-  };
-
-  if (originalDebug) {
-    logger.debug = (message: string, data?: Record<string, unknown>) => {
-      addMonitoringLog({
-        timestamp: new Date().toISOString(),
-        level: 'debug',
-        message,
-        context: logger.context || 'Gateway',
-        ...(data && { data }),
-      });
-      return originalDebug(message, data);
-    };
-  }
-
-  return logger;
-}
+/**
+ * Log capture middleware for monitoring log buffer
+ * Intercepts logger calls and feeds them to the monitoring log buffer
+ */
+
+import { addMonitoringLog } from '../routes/monitoring.js';
+
+/**
+ * Wrap a logger to capture log entries for monitoring
+ * Note: Uses duck typing to avoid strict type checks (compatible with both Logger and memoryLogger)
+ */
+export function wrapLoggerForMonitoring(logger: any): any {
+  // Skip if this doesn't look like a standard logger (e.g., memoryLogger)
+  if (!logger || typeof logger.info !== 'function') {
+    return logger;
+  }
+
+  const originalInfo = logger.info.bind(logger);
+  const originalWarn = logger.warn.bind(logger);
+  const originalError = logger.error.bind(logger);
+  const originalDebug = logger.debug?.bind(logger);
+
+  logger.info = (message: string, data?: Record<string, unknown>) => {
+    addMonitoringLog({
+      timestamp: new Date().toISOString(),
+      level: 'info',
+      message,
+      context: logger.context || 'Gateway',
+      ...(data && { data }),
+    });
+    return originalInfo(message, data);
+  };
+
+  logger.warn = (message: string, data?: Record<string, unknown>) => {
+    addMonitoringLog({
+      timestamp: new Date().toISOString(),
+      level: 'warn',
+      message,
+      context: logger.context || 'Gateway',
+      ...(data && { data }),
+    });
+    return originalWarn(message, data);
+  };
+
+  logger.error = (message: string, data?: Record<string, unknown>) => {
+    addMonitoringLog({
+      timestamp: new Date().toISOString(),
+      level: 'error',
+      message,
+      context: logger.context || 'Gateway',
+      ...(data && { data }),
+    });
+    return originalError(message, data);
+  };
+
+  if (originalDebug) {
+    logger.debug = (message: string, data?: Record<string, unknown>) => {
+      addMonitoringLog({
+        timestamp: new Date().toISOString(),
+        level: 'debug',
+        message,
+        context: logger.context || 'Gateway',
+        ...(data && { data }),
+      });
+      return originalDebug(message, data);
+    };
+  }
+
+  return logger;
+}