tlc-claude-code 1.4.8 → 1.4.9

package/server/lib/monitoring/incident-manager.test.js

@@ -0,0 +1,98 @@
+/**
+ * Incident Manager Tests
+ */
+import { describe, it, expect, vi } from 'vitest';
+import {
+  createIncident,
+  generateTimeline,
+  linkAlerts,
+  updateStatus,
+  generatePostMortem,
+  calculateMttr,
+  INCIDENT_STATUS,
+  createIncidentManager,
+} from './incident-manager.js';
+
+describe('incident-manager', () => {
+  describe('INCIDENT_STATUS', () => {
+    it('defines status constants', () => {
+      expect(INCIDENT_STATUS.OPEN).toBe('open');
+      expect(INCIDENT_STATUS.INVESTIGATING).toBe('investigating');
+      expect(INCIDENT_STATUS.RESOLVED).toBe('resolved');
+    });
+  });
+
+  describe('createIncident', () => {
+    it('creates incident from alert', () => {
+      const incident = createIncident({ alert: { id: 'a1', title: 'DB Down' } });
+      expect(incident.id).toBeDefined();
+      expect(incident.title).toBe('DB Down');
+      expect(incident.status).toBe('open');
+    });
+  });
+
+  describe('generateTimeline', () => {
+    it('generates timeline from events', () => {
+      const timeline = generateTimeline({
+        events: [
+          { type: 'alert', timestamp: new Date('2024-01-01T10:00:00Z') },
+          { type: 'acknowledge', timestamp: new Date('2024-01-01T10:05:00Z') },
+        ],
+      });
+      expect(timeline.length).toBe(2);
+    });
+  });
+
+  describe('linkAlerts', () => {
+    it('links related alerts to incident', () => {
+      const incident = createIncident({ title: 'Outage' });
+      const linked = linkAlerts(incident, [{ id: 'a1' }, { id: 'a2' }]);
+      expect(linked.alerts).toHaveLength(2);
+    });
+  });
+
+  describe('updateStatus', () => {
+    it('updates incident status', () => {
+      const incident = createIncident({ title: 'Test' });
+      const updated = updateStatus(incident, 'investigating');
+      expect(updated.status).toBe('investigating');
+    });
+
+    it('records status history', () => {
+      const incident = createIncident({ title: 'Test' });
+      const updated = updateStatus(incident, 'resolved');
+      expect(updated.statusHistory.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('generatePostMortem', () => {
+    it('generates post-mortem template', () => {
+      const postMortem = generatePostMortem({
+        incident: { id: 'i1', title: 'Outage' },
+      });
+      expect(postMortem).toContain('# Post-Mortem');
+      expect(postMortem).toContain('Outage');
+    });
+  });
+
+  describe('calculateMttr', () => {
+    it('calculates mean time to resolve', () => {
+      const incidents = [
+        { createdAt: new Date('2024-01-01T10:00:00Z'), resolvedAt: new Date('2024-01-01T11:00:00Z') },
+        { createdAt: new Date('2024-01-02T10:00:00Z'), resolvedAt: new Date('2024-01-02T10:30:00Z') },
+      ];
+      const mttr = calculateMttr(incidents);
+      expect(mttr).toBe(45 * 60 * 1000); // 45 minutes
+    });
+  });
+
+  describe('createIncidentManager', () => {
+    it('creates manager with methods', () => {
+      const manager = createIncidentManager();
+      expect(manager.create).toBeDefined();
+      expect(manager.update).toBeDefined();
+      expect(manager.resolve).toBeDefined();
+      expect(manager.getMetrics).toBeDefined();
+    });
+  });
+});

package/server/lib/monitoring/log-aggregator.js

@@ -0,0 +1,147 @@
+/**
+ * Log Aggregator
+ * Collects and aggregates logs from multiple sources
+ */
+
+/**
+ * Log level constants
+ */
+export const LOG_LEVELS = {
+  ERROR: 'error',
+  WARN: 'warn',
+  INFO: 'info',
+  DEBUG: 'debug',
+};
+
+/**
+ * Structures a log entry as JSON with timestamp
+ * @param {Object} entry - Log entry with message and level
+ * @returns {Object} Structured log entry
+ */
+export function structureLog(entry) {
+  return {
+    ...entry,
+    timestamp: entry.timestamp || new Date().toISOString(),
+  };
+}
+
+/**
+ * Filters sensitive data from log entries
+ * @param {Object} log - Log entry to filter
+ * @returns {Object} Filtered log entry
+ */
+export function filterSensitiveData(log) {
+  const sensitivePatterns = [
+    /password\s*[=:]\s*\S+/gi,
+    /api_key\s*[=:]\s*\S+/gi,
+    /secret\s*[=:]\s*\S+/gi,
+    /token\s*[=:]\s*\S+/gi,
+    /authorization\s*[=:]\s*\S+/gi,
+  ];
+
+  let filteredMessage = log.message;
+  for (const pattern of sensitivePatterns) {
+    filteredMessage = filteredMessage.replace(pattern, (match) => {
+      const [key] = match.split(/[=:]/);
+      return `${key}=[REDACTED]`;
+    });
+  }
+
+  return {
+    ...log,
+    message: filteredMessage,
+  };
+}
+
+/**
+ * Aggregates logs from multiple sources
+ * @param {Array} sources - Array of log sources with logs
+ * @returns {Array} Aggregated logs
+ */
+export function aggregateLogs(sources) {
+  const aggregated = [];
+  for (const source of sources) {
+    for (const log of source.logs) {
+      aggregated.push({
+        ...log,
+        source: source.source,
+      });
+    }
+  }
+  return aggregated;
+}
+
+/**
+ * Determines if logs should be rotated
+ * @param {Object} options - Rotation options
+ * @param {number} options.maxSize - Maximum size in bytes
+ * @param {number} options.currentSize - Current size in bytes
+ * @param {number} options.maxAge - Maximum age in milliseconds
+ * @param {number} options.age - Current age in milliseconds
+ * @returns {Object} Rotation result
+ */
+export function rotateLogs(options) {
+  const { maxSize, currentSize, maxAge, age } = options;
+
+  const shouldRotateBySize = maxSize && currentSize && currentSize > maxSize;
+  const shouldRotateByAge = maxAge && age && age > maxAge;
+
+  return {
+    rotated: shouldRotateBySize || shouldRotateByAge,
+    reason: shouldRotateBySize ? 'size' : shouldRotateByAge ? 'age' : null,
+  };
+}
+
+/**
+ * Exports logs to specified format
+ * @param {Array} logs - Logs to export
+ * @param {string} format - Output format (json or ndjson)
+ * @returns {string} Exported logs
+ */
+export function exportLogs(logs, format) {
+  if (format === 'ndjson') {
+    return logs.map(log => JSON.stringify(log)).join('\n');
+  }
+  return JSON.stringify(logs);
+}
+
+/**
+ * Creates a log aggregator instance
+ * @returns {Object} Log aggregator with methods
+ */
+export function createLogAggregator() {
+  const sources = [];
+  const logs = [];
+
+  return {
+    /**
+     * Adds a log source
+     * @param {Object} source - Source configuration
+     */
+    addSource(source) {
+      sources.push(source);
+    },
+
+    /**
+     * Collects logs from all sources
+     * @returns {Array} Collected logs
+     */
+    collect() {
+      const collected = aggregateLogs(sources.map(s => ({
+        source: s.name,
+        logs: s.getLogs ? s.getLogs() : [],
+      })));
+      logs.push(...collected);
+      return collected;
+    },
+
+    /**
+     * Exports all collected logs
+     * @param {string} format - Export format
+     * @returns {string} Exported logs
+     */
+    export(format = 'json') {
+      return exportLogs(logs, format);
+    },
+  };
+}

package/server/lib/monitoring/log-aggregator.test.js

@@ -0,0 +1,89 @@
+/**
+ * Log Aggregator Tests
+ */
+import { describe, it, expect, vi } from 'vitest';
+import {
+  aggregateLogs,
+  structureLog,
+  filterSensitiveData,
+  rotateLogs,
+  exportLogs,
+  LOG_LEVELS,
+  createLogAggregator,
+} from './log-aggregator.js';
+
+describe('log-aggregator', () => {
+  describe('LOG_LEVELS', () => {
+    it('defines level constants', () => {
+      expect(LOG_LEVELS.ERROR).toBe('error');
+      expect(LOG_LEVELS.WARN).toBe('warn');
+      expect(LOG_LEVELS.INFO).toBe('info');
+      expect(LOG_LEVELS.DEBUG).toBe('debug');
+    });
+  });
+
+  describe('structureLog', () => {
+    it('structures log as JSON', () => {
+      const log = structureLog({ message: 'Test', level: 'info' });
+      expect(log.message).toBe('Test');
+      expect(log.level).toBe('info');
+      expect(log.timestamp).toBeDefined();
+    });
+  });
+
+  describe('filterSensitiveData', () => {
+    it('redacts passwords', () => {
+      const log = filterSensitiveData({ message: 'password=secret123' });
+      expect(log.message).not.toContain('secret123');
+      expect(log.message).toContain('[REDACTED]');
+    });
+
+    it('redacts API keys', () => {
+      const log = filterSensitiveData({ message: 'api_key: sk-abc123' });
+      expect(log.message).not.toContain('sk-abc123');
+    });
+  });
+
+  describe('aggregateLogs', () => {
+    it('aggregates from multiple sources', () => {
+      const logs = aggregateLogs([
+        { source: 'app', logs: [{ message: 'a' }] },
+        { source: 'db', logs: [{ message: 'b' }] },
+      ]);
+      expect(logs.length).toBe(2);
+    });
+  });
+
+  describe('rotateLogs', () => {
+    it('rotates by size', () => {
+      const result = rotateLogs({ maxSize: 1000, currentSize: 1500 });
+      expect(result.rotated).toBe(true);
+    });
+
+    it('rotates by time', () => {
+      const result = rotateLogs({ maxAge: 86400000, age: 90000000 });
+      expect(result.rotated).toBe(true);
+    });
+  });
+
+  describe('exportLogs', () => {
+    it('exports to JSON', () => {
+      const output = exportLogs([{ message: 'test' }], 'json');
+      expect(JSON.parse(output)).toHaveLength(1);
+    });
+
+    it('exports to NDJSON', () => {
+      const output = exportLogs([{ message: 'a' }, { message: 'b' }], 'ndjson');
+      expect(output.split('\n').filter(Boolean)).toHaveLength(2);
+    });
+  });
+
+  describe('createLogAggregator', () => {
+    it('creates aggregator with methods', () => {
+      const aggregator = createLogAggregator();
+      expect(aggregator.addSource).toBeDefined();
+      expect(aggregator.collect).toBeDefined();
+      expect(aggregator.export).toBeDefined();
+    });
+  });
+});

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

@@ -0,0 +1,337 @@
+/**
+ * Metrics Collector
+ * Prometheus format metrics collection and formatting
+ */
+
+export const METRIC_TYPES = {
+  COUNTER: 'counter',
+  HISTOGRAM: 'histogram',
+  GAUGE: 'gauge',
+};
+
+/**
+ * Create a counter metric
+ * @param {string} name - Metric name
+ * @param {Object} options - Configuration options
+ * @param {Array} options.labels - Label names
+ * @returns {Object} Counter with inc and get methods
+ */
+export function createCounter(name, options = {}) {
+  const { labels = [] } = options;
+  let value = 0;
+  const labeledValues = new Map();
+
+  function getLabelKey(labelValues) {
+    return JSON.stringify(labelValues);
+  }
+
+  return {
+    inc(amountOrLabels = 1) {
+      if (typeof amountOrLabels === 'number') {
+        value += amountOrLabels;
+      } else if (typeof amountOrLabels === 'object' && labels.length > 0) {
+        const key = getLabelKey(amountOrLabels);
+        labeledValues.set(key, (labeledValues.get(key) || 0) + 1);
+      } else {
+        value += 1;
+      }
+    },
+
+    get(labelValues) {
+      if (labelValues && labels.length > 0) {
+        const key = getLabelKey(labelValues);
+        return labeledValues.get(key) || 0;
+      }
+      return value;
+    },
+
+    getName() {
+      return name;
+    },
+
+    getType() {
+      return METRIC_TYPES.COUNTER;
+    },
+  };
+}
+
+/**
+ * Create a histogram metric
+ * @param {string} name - Metric name
+ * @param {Object} options - Configuration options
+ * @param {Array} options.buckets - Bucket boundaries
+ * @returns {Object} Histogram with observe and get methods
+ */
+export function createHistogram(name, options = {}) {
+  const { buckets = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10] } = options;
+  const observations = [];
+  let sum = 0;
+
+  return {
+    observe(value) {
+      observations.push(value);
+      sum += value;
+    },
+
+    getCount() {
+      return observations.length;
+    },
+
+    getSum() {
+      return sum;
+    },
+
+    getPercentile(percentile) {
+      if (observations.length === 0) return 0;
+
+      const sorted = [...observations].sort((a, b) => a - b);
+      const index = Math.floor((percentile / 100) * sorted.length);
+      return sorted[Math.min(index, sorted.length - 1)];
+    },
+
+    getBuckets() {
+      const result = {};
+      for (const bucket of buckets) {
+        result[bucket] = observations.filter((v) => v <= bucket).length;
+      }
+      return result;
+    },
+
+    getName() {
+      return name;
+    },
+
+    getType() {
+      return METRIC_TYPES.HISTOGRAM;
+    },
+  };
+}
+
+/**
+ * Create a gauge metric
+ * @param {string} name - Metric name
+ * @param {Object} options - Configuration options
+ * @returns {Object} Gauge with set, inc, dec, and get methods
+ */
+export function createGauge(name, options = {}) {
+  let value = 0;
+
+  return {
+    set(newValue) {
+      value = newValue;
+    },
+
+    inc(amount = 1) {
+      value += amount;
+    },
+
+    dec(amount = 1) {
+      value -= amount;
+    },
+
+    get() {
+      return value;
+    },
+
+    getName() {
+      return name;
+    },
+
+    getType() {
+      return METRIC_TYPES.GAUGE;
+    },
+  };
+}
+
+/**
+ * Collect system metrics
+ * @param {Object} options - Configuration options
+ * @param {boolean} options.cpu - Include CPU metrics
+ * @param {boolean} options.memory - Include memory metrics
+ * @param {boolean} options.eventLoop - Include event loop metrics
+ * @returns {Object} Collected metrics
+ */
+export async function collectMetrics(options = {}) {
+  const { cpu = false, memory = false, eventLoop = false } = options;
+  const metrics = {};
+
+  if (cpu) {
+    const cpuUsage = process.cpuUsage();
+    metrics.cpu = {
+      user: cpuUsage.user,
+      system: cpuUsage.system,
+    };
+  }
+
+  if (memory) {
+    const memUsage = process.memoryUsage();
+    metrics.memory = {
+      heapUsed: memUsage.heapUsed,
+      heapTotal: memUsage.heapTotal,
+      external: memUsage.external,
+      rss: memUsage.rss,
+    };
+  }
+
+  if (eventLoop) {
+    // Measure event loop lag
+    const start = Date.now();
+    await new Promise((resolve) => setImmediate(resolve));
+    const lag = Date.now() - start;
+    metrics.eventLoop = {
+      lag,
+    };
+  }
+
+  return metrics;
+}
+
+/**
+ * Format metric in Prometheus format
+ * @param {Object} metric - Metric to format
+ * @param {string} metric.name - Metric name
+ * @param {string} metric.type - Metric type
+ * @param {number} metric.value - Metric value (for counter/gauge)
+ * @param {Object} metric.buckets - Bucket values (for histogram)
+ * @param {number} metric.sum - Sum (for histogram)
+ * @param {number} metric.count - Count (for histogram)
+ * @param {Object} metric.labels - Labels
+ * @returns {string} Prometheus formatted string
+ */
+export function formatPrometheus(metric) {
+  const { name, type, value, buckets, sum, count, labels } = metric;
+  const lines = [];
+
+  // Type declaration
+  lines.push(`# TYPE ${name} ${type}`);
+
+  // Format labels
+  let labelStr = '';
+  if (labels && Object.keys(labels).length > 0) {
+    const labelParts = Object.entries(labels).map(([k, v]) => `${k}="${v}"`);
+    labelStr = `{${labelParts.join(',')}}`;
+  }
+
+  if (type === 'histogram') {
+    // Histogram buckets
+    for (const [le, bucketCount] of Object.entries(buckets)) {
+      const bucketLabel = labelStr ? labelStr.replace('}', `,le="${le}"}`) : `{le="${le}"}`;
+      lines.push(`${name}_bucket${bucketLabel} ${bucketCount}`);
+    }
+    // Add +Inf bucket
+    const infLabel = labelStr ? labelStr.replace('}', ',le="+Inf"}') : '{le="+Inf"}';
+    lines.push(`${name}_bucket${infLabel} ${count}`);
+    lines.push(`${name}_sum${labelStr} ${sum}`);
+    lines.push(`${name}_count${labelStr} ${count}`);
+  } else {
+    // Counter or Gauge
+    lines.push(`${name}${labelStr} ${value}`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Create a metrics collector
+ * @param {Object} options - Configuration options
+ * @param {number} options.retentionMs - Retention period in milliseconds
+ * @returns {Object} Metrics collector
+ */
+export function createMetricsCollector(options = {}) {
+  const { retentionMs = 3600000 } = options;
+
+  const counters = new Map();
+  const histograms = new Map();
+  const gauges = new Map();
+  const requestMetrics = [];
+
+  // Create default request metrics
+  const requestCounter = createCounter('http_requests_total', { labels: ['method', 'path', 'status'] });
+  const requestDuration = createHistogram('http_request_duration_seconds');
+
+  return {
+    counter(name, opts) {
+      if (!counters.has(name)) {
+        counters.set(name, createCounter(name, opts));
+      }
+      return counters.get(name);
+    },
+
+    histogram(name, opts) {
+      if (!histograms.has(name)) {
+        histograms.set(name, createHistogram(name, opts));
+      }
+      return histograms.get(name);
+    },
+
+    gauge(name, opts) {
+      if (!gauges.has(name)) {
+        gauges.set(name, createGauge(name, opts));
+      }
+      return gauges.get(name);
+    },
+
+    trackRequest({ method, path, status, duration }) {
+      requestCounter.inc({ method, path, status: String(status) });
+      requestDuration.observe(duration);
+      requestMetrics.push({
+        method,
+        path,
+        status,
+        duration,
+        timestamp: Date.now(),
+      });
+
+      // Clean up old metrics based on retention
+      const cutoff = Date.now() - retentionMs;
+      while (requestMetrics.length > 0 && requestMetrics[0].timestamp < cutoff) {
+        requestMetrics.shift();
+      }
+    },
+
+    collect() {
+      return {
+        counters: Object.fromEntries(counters),
+        histograms: Object.fromEntries(histograms),
+        gauges: Object.fromEntries(gauges),
+        requests: requestMetrics,
+      };
+    },
+
+    format() {
+      const output = [];
+
+      for (const [name, counter] of counters) {
+        output.push(formatPrometheus({
+          name,
+          type: 'counter',
+          value: counter.get(),
+        }));
+      }
+
+      for (const [name, histogram] of histograms) {
+        output.push(formatPrometheus({
+          name,
+          type: 'histogram',
+          buckets: histogram.getBuckets(),
+          sum: histogram.getSum(),
+          count: histogram.getCount(),
+        }));
+      }
+
+      for (const [name, gauge] of gauges) {
+        output.push(formatPrometheus({
+          name,
+          type: 'gauge',
+          value: gauge.get(),
+        }));
+      }
+
+      return output.join('\n\n');
+    },
+
+    getRetention() {
+      return retentionMs;
+    },
+  };
+}