tlc-claude-code 1.4.8 → 1.4.9

package/server/lib/monitoring/metrics-collector.test.js

@@ -0,0 +1,172 @@
+/**
+ * Metrics Collector Tests
+ */
+import { describe, it, expect, vi } from 'vitest';
+import {
+  createCounter,
+  createHistogram,
+  createGauge,
+  collectMetrics,
+  formatPrometheus,
+  METRIC_TYPES,
+  createMetricsCollector,
+} from './metrics-collector.js';
+
+describe('metrics-collector', () => {
+  describe('METRIC_TYPES', () => {
+    it('defines metric type constants', () => {
+      expect(METRIC_TYPES.COUNTER).toBe('counter');
+      expect(METRIC_TYPES.HISTOGRAM).toBe('histogram');
+      expect(METRIC_TYPES.GAUGE).toBe('gauge');
+    });
+  });
+
+  describe('createCounter', () => {
+    it('creates counter with initial value 0', () => {
+      const counter = createCounter('http_requests_total');
+      expect(counter.get()).toBe(0);
+    });
+
+    it('increments counter', () => {
+      const counter = createCounter('http_requests_total');
+      counter.inc();
+      expect(counter.get()).toBe(1);
+    });
+
+    it('increments by specific value', () => {
+      const counter = createCounter('http_requests_total');
+      counter.inc(5);
+      expect(counter.get()).toBe(5);
+    });
+
+    it('supports labels', () => {
+      const counter = createCounter('http_requests_total', { labels: ['method', 'status'] });
+      counter.inc({ method: 'GET', status: '200' });
+      expect(counter.get({ method: 'GET', status: '200' })).toBe(1);
+    });
+  });
+
+  describe('createHistogram', () => {
+    it('records observations', () => {
+      const histogram = createHistogram('http_request_duration_seconds');
+      histogram.observe(0.5);
+      expect(histogram.getCount()).toBe(1);
+    });
+
+    it('calculates percentiles', () => {
+      const histogram = createHistogram('http_request_duration_seconds');
+      for (let i = 0; i < 100; i++) histogram.observe(i / 100);
+
+      expect(histogram.getPercentile(50)).toBeCloseTo(0.5, 1);
+      expect(histogram.getPercentile(95)).toBeCloseTo(0.95, 1);
+      expect(histogram.getPercentile(99)).toBeCloseTo(0.99, 1);
+    });
+
+    it('tracks sum', () => {
+      const histogram = createHistogram('http_request_duration_seconds');
+      histogram.observe(1);
+      histogram.observe(2);
+      expect(histogram.getSum()).toBe(3);
+    });
+  });
+
+  describe('createGauge', () => {
+    it('sets value', () => {
+      const gauge = createGauge('memory_usage_bytes');
+      gauge.set(1024);
+      expect(gauge.get()).toBe(1024);
+    });
+
+    it('increments value', () => {
+      const gauge = createGauge('active_connections');
+      gauge.set(10);
+      gauge.inc();
+      expect(gauge.get()).toBe(11);
+    });
+
+    it('decrements value', () => {
+      const gauge = createGauge('active_connections');
+      gauge.set(10);
+      gauge.dec();
+      expect(gauge.get()).toBe(9);
+    });
+  });
+
+  describe('collectMetrics', () => {
+    it('collects CPU usage', async () => {
+      const metrics = await collectMetrics({ cpu: true });
+      expect(metrics.cpu).toBeDefined();
+    });
+
+    it('collects memory usage', async () => {
+      const metrics = await collectMetrics({ memory: true });
+      expect(metrics.memory).toBeDefined();
+      expect(metrics.memory.heapUsed).toBeDefined();
+    });
+
+    it('collects event loop lag', async () => {
+      const metrics = await collectMetrics({ eventLoop: true });
+      expect(metrics.eventLoop).toBeDefined();
+    });
+  });
+
+  describe('formatPrometheus', () => {
+    it('formats counter metric', () => {
+      const output = formatPrometheus({
+        name: 'http_requests_total',
+        type: 'counter',
+        value: 100,
+      });
+      expect(output).toContain('# TYPE http_requests_total counter');
+      expect(output).toContain('http_requests_total 100');
+    });
+
+    it('formats histogram metric', () => {
+      const output = formatPrometheus({
+        name: 'http_request_duration_seconds',
+        type: 'histogram',
+        buckets: { 0.1: 10, 0.5: 50, 1: 100 },
+        sum: 25,
+        count: 100,
+      });
+      expect(output).toContain('# TYPE http_request_duration_seconds histogram');
+      expect(output).toContain('_bucket');
+      expect(output).toContain('_sum');
+      expect(output).toContain('_count');
+    });
+
+    it('includes labels', () => {
+      const output = formatPrometheus({
+        name: 'http_requests_total',
+        type: 'counter',
+        value: 100,
+        labels: { method: 'GET', status: '200' },
+      });
+      expect(output).toContain('{method="GET",status="200"}');
+    });
+  });
+
+  describe('createMetricsCollector', () => {
+    it('creates collector with methods', () => {
+      const collector = createMetricsCollector();
+      expect(collector.counter).toBeDefined();
+      expect(collector.histogram).toBeDefined();
+      expect(collector.gauge).toBeDefined();
+      expect(collector.collect).toBeDefined();
+      expect(collector.format).toBeDefined();
+    });
+
+    it('tracks request metrics', () => {
+      const collector = createMetricsCollector();
+      collector.trackRequest({ method: 'GET', path: '/api/users', status: 200, duration: 0.1 });
+
+      const metrics = collector.collect();
+      expect(metrics.requests).toBeDefined();
+    });
+
+    it('configures retention period', () => {
+      const collector = createMetricsCollector({ retentionMs: 3600000 });
+      expect(collector.getRetention()).toBe(3600000);
+    });
+  });
+});

package/server/lib/monitoring/status-page.js

@@ -0,0 +1,214 @@
+/**
+ * Status Page Generator
+ * Generates HTML status pages and RSS feeds
+ */
+
+/**
+ * Component status constants
+ */
+export const COMPONENT_STATUS = {
+  OPERATIONAL: 'operational',
+  DEGRADED: 'degraded',
+  OUTAGE: 'outage',
+  MAINTENANCE: 'maintenance',
+};
+
+/**
+ * Gets component status based on health metrics
+ * @param {Object} component - Component health data
+ * @param {boolean} component.healthy - Is component healthy
+ * @param {number} component.responseTime - Response time in ms
+ * @param {number} component.threshold - Response time threshold
+ * @returns {string} Component status
+ */
+export function getComponentStatus(component) {
+  if (!component.healthy) {
+    return COMPONENT_STATUS.OUTAGE;
+  }
+
+  if (component.threshold && component.responseTime > component.threshold) {
+    return COMPONENT_STATUS.DEGRADED;
+  }
+
+  return COMPONENT_STATUS.OPERATIONAL;
+}
+
+/**
+ * Calculates overall status from components
+ * @param {Array} components - Component statuses
+ * @returns {string} Overall status
+ */
+function getOverallStatus(components) {
+  if (components.some(c => c.status === COMPONENT_STATUS.OUTAGE)) {
+    return COMPONENT_STATUS.OUTAGE;
+  }
+  if (components.some(c => c.status === COMPONENT_STATUS.MAINTENANCE)) {
+    return COMPONENT_STATUS.MAINTENANCE;
+  }
+  if (components.some(c => c.status === COMPONENT_STATUS.DEGRADED)) {
+    return COMPONENT_STATUS.DEGRADED;
+  }
+  return COMPONENT_STATUS.OPERATIONAL;
+}
+
+/**
+ * Generates an HTML status page
+ * @param {Object} options - Page options
+ * @param {string} options.title - Page title
+ * @param {Array} options.components - Component statuses
+ * @param {Array} options.incidents - Recent incidents
+ * @returns {string} HTML status page
+ */
+export function generateStatusPage(options) {
+  const { title = 'Status Page', components = [], incidents = [] } = options;
+  const overall = getOverallStatus(components);
+
+  const componentHtml = components
+    .map(c => `<div class="component ${c.status}"><span class="name">${c.name}</span><span class="status">${c.status}</span></div>`)
+    .join('\n');
+
+  const incidentHtml = incidents.length > 0
+    ? formatIncidentHistory(incidents)
+    : '<p>No recent incidents</p>';
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+  <style>
+    body { font-family: system-ui, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
+    .overall { padding: 20px; border-radius: 8px; margin-bottom: 20px; }
+    .overall.operational { background: #d4edda; }
+    .overall.degraded { background: #fff3cd; }
+    .overall.outage { background: #f8d7da; }
+    .overall.maintenance { background: #cce5ff; }
+    .component { display: flex; justify-content: space-between; padding: 10px; border-bottom: 1px solid #eee; }
+    .incident { margin-bottom: 15px; padding: 10px; background: #f8f9fa; border-radius: 4px; }
+  </style>
+</head>
+<body>
+  <h1>${title}</h1>
+  <div class="overall ${overall}">
+    <strong>Overall Status:</strong> ${overall}
+  </div>
+  <h2>Components</h2>
+  <div class="components">
+    ${componentHtml}
+  </div>
+  <h2>Incident History</h2>
+  <div class="incidents">
+    ${incidentHtml}
+  </div>
+</body>
+</html>`;
+}
+
+/**
+ * Formats incident history as HTML
+ * @param {Array} incidents - Incidents to format
+ * @returns {string} HTML incident list
+ */
+export function formatIncidentHistory(incidents) {
+  return incidents
+    .map(incident => `<div class="incident">
+  <h3>${incident.title}</h3>
+  <p><strong>Date:</strong> ${incident.date}</p>
+  <p><strong>Status:</strong> ${incident.status}</p>
+</div>`)
+    .join('\n');
+}
+
+/**
+ * Generates an RSS feed for status updates
+ * @param {Object} options - Feed options
+ * @param {string} options.title - Feed title
+ * @param {Array} options.incidents - Incidents to include
+ * @returns {string} RSS XML
+ */
+export function generateRssFeed(options) {
+  const { title = 'Status Updates', incidents = [] } = options;
+
+  const items = incidents
+    .map(incident => `    <item>
+      <title>${incident.title}</title>
+      <pubDate>${incident.date}</pubDate>
+    </item>`)
+    .join('\n');
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title>${title}</title>
+    <description>Status updates and incidents</description>
+${items}
+  </channel>
+</rss>`;
+}
+
+/**
+ * Creates a status page generator instance
+ * @returns {Object} Generator with methods
+ */
+export function createStatusPageGenerator() {
+  const components = [];
+  const incidents = [];
+  const maintenanceSchedule = [];
+
+  return {
+    /**
+     * Adds a component to track
+     * @param {Object} component - Component configuration
+     */
+    addComponent(component) {
+      components.push(component);
+    },
+
+    /**
+     * Adds an incident
+     * @param {Object} incident - Incident to add
+     */
+    addIncident(incident) {
+      incidents.push(incident);
+    },
+
+    /**
+     * Schedules maintenance for a component
+     * @param {Object} maintenance - Maintenance schedule
+     */
+    scheduleMaintenance(maintenance) {
+      maintenanceSchedule.push(maintenance);
+
+      // Find component and update its status
+      const componentIndex = components.findIndex(c => c.name === maintenance.component);
+      if (componentIndex >= 0) {
+        components[componentIndex].status = COMPONENT_STATUS.MAINTENANCE;
+      } else {
+        components.push({
+          name: maintenance.component,
+          status: COMPONENT_STATUS.MAINTENANCE,
+        });
+      }
+    },
+
+    /**
+     * Generates the status page HTML
+     * @returns {string} HTML status page
+     */
+    generate() {
+      return generateStatusPage({
+        components,
+        incidents,
+      });
+    },
+
+    /**
+     * Gets RSS feed
+     * @returns {string} RSS XML
+     */
+    getRss() {
+      return generateRssFeed({ incidents });
+    },
+  };
+}

package/server/lib/monitoring/status-page.test.js

@@ -0,0 +1,105 @@
+/**
+ * Status Page Generator Tests
+ */
+import { describe, it, expect } from 'vitest';
+import {
+  generateStatusPage,
+  getComponentStatus,
+  formatIncidentHistory,
+  generateRssFeed,
+  COMPONENT_STATUS,
+  createStatusPageGenerator,
+} from './status-page.js';
+
+describe('status-page', () => {
+  describe('COMPONENT_STATUS', () => {
+    it('defines status constants', () => {
+      expect(COMPONENT_STATUS.OPERATIONAL).toBe('operational');
+      expect(COMPONENT_STATUS.DEGRADED).toBe('degraded');
+      expect(COMPONENT_STATUS.OUTAGE).toBe('outage');
+      expect(COMPONENT_STATUS.MAINTENANCE).toBe('maintenance');
+    });
+  });
+
+  describe('generateStatusPage', () => {
+    it('generates HTML status page', () => {
+      const html = generateStatusPage({
+        title: 'Service Status',
+        components: [{ name: 'API', status: 'operational' }],
+      });
+      expect(html).toContain('<html');
+      expect(html).toContain('Service Status');
+      expect(html).toContain('API');
+    });
+
+    it('shows overall status', () => {
+      const html = generateStatusPage({
+        components: [
+          { name: 'API', status: 'operational' },
+          { name: 'DB', status: 'degraded' },
+        ],
+      });
+      expect(html).toContain('degraded');
+    });
+  });
+
+  describe('getComponentStatus', () => {
+    it('returns operational for healthy component', () => {
+      const status = getComponentStatus({ healthy: true, responseTime: 100 });
+      expect(status).toBe('operational');
+    });
+
+    it('returns degraded for slow component', () => {
+      const status = getComponentStatus({ healthy: true, responseTime: 5000, threshold: 1000 });
+      expect(status).toBe('degraded');
+    });
+
+    it('returns outage for unhealthy component', () => {
+      const status = getComponentStatus({ healthy: false });
+      expect(status).toBe('outage');
+    });
+  });
+
+  describe('formatIncidentHistory', () => {
+    it('formats incident list', () => {
+      const html = formatIncidentHistory([
+        { title: 'API Outage', date: '2024-01-01', status: 'resolved' },
+      ]);
+      expect(html).toContain('API Outage');
+      expect(html).toContain('resolved');
+    });
+  });
+
+  describe('generateRssFeed', () => {
+    it('generates RSS feed', () => {
+      const rss = generateRssFeed({
+        title: 'Status Updates',
+        incidents: [{ title: 'Outage', date: '2024-01-01' }],
+      });
+      expect(rss).toContain('<?xml');
+      expect(rss).toContain('<rss');
+      expect(rss).toContain('Outage');
+    });
+  });
+
+  describe('createStatusPageGenerator', () => {
+    it('creates generator with methods', () => {
+      const generator = createStatusPageGenerator();
+      expect(generator.generate).toBeDefined();
+      expect(generator.addComponent).toBeDefined();
+      expect(generator.addIncident).toBeDefined();
+      expect(generator.getRss).toBeDefined();
+    });
+
+    it('supports scheduled maintenance', () => {
+      const generator = createStatusPageGenerator();
+      generator.scheduleMaintenance({
+        component: 'API',
+        start: new Date(),
+        end: new Date(Date.now() + 3600000),
+      });
+      const page = generator.generate();
+      expect(page).toContain('maintenance');
+    });
+  });
+});

package/server/lib/monitoring/uptime-monitor.js

@@ -0,0 +1,194 @@
+/**
+ * Uptime Monitor
+ * Uptime monitoring and alerting
+ */
+
+export const UPTIME_STATUS = {
+  UP: 'up',
+  DOWN: 'down',
+  DEGRADED: 'degraded',
+};
+
+/**
+ * Ping an endpoint and return status
+ * @param {string} url - URL to ping
+ * @param {Object} options - Configuration options
+ * @param {Function} options.fetch - Fetch function
+ * @param {number} options.timeout - Timeout in ms
+ * @returns {Object} Ping result with status and response time
+ */
+export async function pingEndpoint(url, options = {}) {
+  const { fetch: fetchFn = fetch, timeout = 5000 } = options;
+
+  const startTime = Date.now();
+
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    const fetchPromise = fetchFn(url, { signal: controller.signal });
+    const timeoutPromise = new Promise((_, reject) =>
+      setTimeout(() => reject(new Error('timeout')), timeout)
+    );
+
+    const response = await Promise.race([fetchPromise, timeoutPromise]);
+    clearTimeout(timeoutId);
+
+    const responseTime = Date.now() - startTime;
+
+    if (response.ok) {
+      return {
+        status: UPTIME_STATUS.UP,
+        responseTime,
+        statusCode: response.status,
+      };
+    } else {
+      return {
+        status: UPTIME_STATUS.DOWN,
+        responseTime,
+        statusCode: response.status,
+      };
+    }
+  } catch (error) {
+    const responseTime = Date.now() - startTime;
+
+    if (error.message === 'timeout' || error.name === 'AbortError') {
+      return {
+        status: UPTIME_STATUS.DOWN,
+        responseTime,
+        error: 'timeout',
+      };
+    }
+
+    return {
+      status: UPTIME_STATUS.DOWN,
+      responseTime,
+      error: error.message,
+    };
+  }
+}
+
+/**
+ * Calculate uptime percentage from check results
+ * @param {Array} checks - Array of check results
+ * @returns {number} Uptime percentage
+ */
+export function calculateUptime(checks) {
+  if (checks.length === 0) return 100;
+
+  const upCount = checks.filter((check) => check.status === UPTIME_STATUS.UP).length;
+  return (upCount / checks.length) * 100;
+}
+
+/**
+ * Generate an uptime report
+ * @param {Object} options - Report options
+ * @param {string} options.endpoint - Endpoint URL
+ * @param {string} options.period - Report period (day, week, month)
+ * @param {Array} options.checks - Check results
+ * @returns {Object} Uptime report
+ */
+export function generateUptimeReport(options = {}) {
+  const { endpoint, period = 'day', checks = [] } = options;
+
+  const uptime = calculateUptime(checks);
+
+  // Calculate average response time
+  const responseTimes = checks
+    .filter((c) => c.responseTime !== undefined)
+    .map((c) => c.responseTime);
+
+  const avgResponseTime =
+    responseTimes.length > 0
+      ? responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length
+      : 0;
+
+  // Count incidents (transitions from up to down)
+  let incidents = 0;
+  for (let i = 1; i < checks.length; i++) {
+    if (checks[i - 1].status === UPTIME_STATUS.UP && checks[i].status === UPTIME_STATUS.DOWN) {
+      incidents++;
+    }
+  }
+
+  return {
+    endpoint,
+    period,
+    uptime,
+    avgResponseTime,
+    totalChecks: checks.length,
+    incidents,
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Create an uptime monitor
+ * @param {Object} options - Configuration options
+ * @param {Function} options.fetch - Fetch function
+ * @param {number} options.interval - Check interval in ms
+ * @returns {Object} Uptime monitor
+ */
+export function createUptimeMonitor(options = {}) {
+  const { fetch: fetchFn = fetch, interval = 60000 } = options;
+
+  const endpoints = new Map();
+  const checkHistory = new Map();
+
+  return {
+    addEndpoint(url, endpointOptions = {}) {
+      endpoints.set(url, {
+        url,
+        ...endpointOptions,
+      });
+      checkHistory.set(url, []);
+    },
+
+    removeEndpoint(url) {
+      endpoints.delete(url);
+      checkHistory.delete(url);
+    },
+
+    getEndpoints() {
+      return Array.from(endpoints.values());
+    },
+
+    async check(url) {
+      const urlsToCheck = url ? [url] : Array.from(endpoints.keys());
+
+      for (const endpointUrl of urlsToCheck) {
+        const result = await pingEndpoint(endpointUrl, { fetch: fetchFn });
+        result.timestamp = Date.now();
+
+        const history = checkHistory.get(endpointUrl) || [];
+        history.push(result);
+        checkHistory.set(endpointUrl, history);
+      }
+    },
+
+    getStatus(url) {
+      const history = checkHistory.get(url);
+      if (!history || history.length === 0) {
+        return UPTIME_STATUS.UP; // Default to up if no checks
+      }
+      return history[history.length - 1].status;
+    },
+
+    getHistory(url) {
+      return checkHistory.get(url) || [];
+    },
+
+    getReport(url, period = 'day') {
+      const history = checkHistory.get(url) || [];
+      return generateUptimeReport({
+        endpoint: url,
+        period,
+        checks: history,
+      });
+    },
+
+    getInterval() {
+      return interval;
+    },
+  };
+}