fast-ops-fix-cli 0.1.0

package/bin/fast-ops-fix.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+import { analyzeIncident } from "../src/analyze.js";
+import { formatTextReport } from "../src/output.js";
+
+const VERSION = "0.1.0";
+
+function printUsage() {
+  console.log(`fast-ops-fix v${VERSION}
+
+Usage:
+  fast-ops-fix --file <logfile> [--json] [--max-evidence <n>]
+  fast-ops-fix <logfile> [--json]
+  cat app.log | fast-ops-fix [--json]
+
+Options:
+  -f, --file <path>       Read logs from file
+  --json                  Emit machine-readable JSON output
+  --max-evidence <n>      Evidence lines per signal (default: 3)
+  -v, --version           Print version
+  -h, --help              Show this help
+`);
+}
+
+function parseArgs(argv) {
+  const options = {
+    file: null,
+    json: false,
+    maxEvidence: 3,
+    help: false,
+    version: false
+  };
+
+  const positionals = [];
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+
+    if (token === "-h" || token === "--help") {
+      options.help = true;
+      continue;
+    }
+
+    if (token === "-v" || token === "--version") {
+      options.version = true;
+      continue;
+    }
+
+    if (token === "--json") {
+      options.json = true;
+      continue;
+    }
+
+    if (token === "-f" || token === "--file") {
+      const value = argv[i + 1];
+      if (!value) {
+        throw new Error("--file requires a value");
+      }
+      options.file = value;
+      i += 1;
+      continue;
+    }
+
+    if (token === "--max-evidence") {
+      const value = argv[i + 1];
+      if (!value || !/^\d+$/.test(value) || Number(value) < 1) {
+        throw new Error("--max-evidence requires a positive integer");
+      }
+      options.maxEvidence = Number(value);
+      i += 1;
+      continue;
+    }
+
+    if (token.startsWith("-")) {
+      throw new Error(`Unknown option: ${token}`);
+    }
+
+    positionals.push(token);
+  }
+
+  if (!options.file && positionals.length > 0) {
+    options.file = positionals[0];
+  }
+
+  if (positionals.length > 1) {
+    throw new Error("Only one logfile path may be provided");
+  }
+
+  return options;
+}
+
+async function readFromStdin() {
+  let data = "";
+  for await (const chunk of process.stdin) {
+    data += chunk;
+  }
+  return data;
+}
+
+async function resolveInput(filePath) {
+  if (filePath) {
+    return readFile(filePath, "utf8");
+  }
+  if (!process.stdin.isTTY) {
+    return readFromStdin();
+  }
+  return "";
+}
+
+async function main() {
+  let options;
+
+  try {
+    options = parseArgs(process.argv.slice(2));
+  } catch (error) {
+    console.error(`Argument error: ${error.message}`);
+    printUsage();
+    process.exit(1);
+  }
+
+  if (options.help) {
+    printUsage();
+    return;
+  }
+
+  if (options.version) {
+    console.log(VERSION);
+    return;
+  }
+
+  const input = await resolveInput(options.file);
+  if (!input || input.trim().length === 0) {
+    console.error("No input provided. Pass --file <logfile> or pipe logs via stdin.");
+    printUsage();
+    process.exit(1);
+  }
+
+  const report = analyzeIncident(input, { maxEvidence: options.maxEvidence });
+
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+
+  console.log(formatTextReport(report));
+}
+
+main().catch((error) => {
+  console.error(`Execution error: ${error.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "fast-ops-fix-cli",
+  "version": "0.1.0",
+  "description": "CLI for incident first-response triage from web service logs.",
+  "type": "module",
+  "main": "./src/analyze.js",
+  "exports": {
+    ".": "./src/analyze.js"
+  },
+  "bin": {
+    "fast-ops-fix": "bin/fast-ops-fix.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "lint": "node --check ./bin/fast-ops-fix.js && node --check ./src/analyze.js && node --check ./src/output.js",
+    "test": "node --test"
+  },
+  "keywords": [
+    "incident",
+    "triage",
+    "ops",
+    "sre",
+    "logs",
+    "502",
+    "504"
+  ],
+  "author": "autonomy414941",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  }
+}

package/src/analyze.js

@@ -0,0 +1,192 @@
+const RULES = [
+  {
+    id: "upstream_unreachable",
+    title: "Upstream process unavailable or wrong target",
+    weight: 10,
+    pattern:
+      /(connection refused|econnrefused|no route to host|host unreachable|upstream prematurely closed connection|connect\(\) failed \(111|dial tcp .*: connect: connection refused)/i,
+    nextChecks: [
+      "Check the upstream process/container is running and bound to the expected host:port.",
+      "Run: ss -lntp | grep -E ':(80|443|3000|8000|8080|9000)\\b'",
+      "Run: curl -sv http://127.0.0.1:<app-port>/health"
+    ],
+    possibleFixes: [
+      "Fix upstream host/port in proxy config.",
+      "Restart failed upstream process after confirming root cause.",
+      "Add or fix readiness checks so proxy only routes to healthy targets."
+    ]
+  },
+  {
+    id: "gateway_timeout",
+    title: "Gateway/proxy timeout on long request",
+    weight: 8,
+    pattern:
+      /(504\b|gateway timeout|upstream timed out|context deadline exceeded|response header timeout|read timeout|operation timed out|deadline exceeded)/i,
+    nextChecks: [
+      "Measure direct upstream latency bypassing the gateway.",
+      "Compare proxy timeout values against real endpoint execution time.",
+      "Run: time curl -sv http://127.0.0.1:<app-port>/<slow-endpoint>"
+    ],
+    possibleFixes: [
+      "Increase proxy timeout only for affected routes.",
+      "Move expensive sync work to async/background processing.",
+      "Add indexes/caching for slow backend queries."
+    ]
+  },
+  {
+    id: "bad_gateway_generic",
+    title: "Proxy receives invalid upstream response",
+    weight: 6,
+    pattern: /(502\b|bad gateway|err_incomplete_chunked_encoding)/i,
+    nextChecks: [
+      "Correlate proxy access/error logs with app logs at the same UTC timestamp.",
+      "Verify upstream response headers and transfer encoding are valid.",
+      "Run: curl -sv --http1.1 http://127.0.0.1:<app-port>/<path>"
+    ],
+    possibleFixes: [
+      "Fix upstream crashes/panics that terminate responses early.",
+      "Disable/adjust buffering or chunked encoding behavior for streaming endpoints.",
+      "Align proxy and upstream protocol settings (HTTP/1.1 vs HTTP/2)."
+    ]
+  },
+  {
+    id: "oom_or_restart",
+    title: "Upstream process restart or memory pressure",
+    weight: 8,
+    pattern:
+      /(oomkilled|out of memory|killed process \d+|signal: killed|container restarted|exit code 137|memory cgroup out of memory)/i,
+    nextChecks: [
+      "Inspect container/service restart count around failure timestamp.",
+      "Check kernel/system logs for OOM kills.",
+      "Run: journalctl -k --since '-30 min' | grep -Ei 'oom|killed process'"
+    ],
+    possibleFixes: [
+      "Increase memory limit or reduce peak memory usage.",
+      "Cap concurrency or request payload size for heavy endpoints.",
+      "Add graceful backpressure instead of allowing process termination."
+    ]
+  },
+  {
+    id: "dns_or_tls",
+    title: "DNS or TLS handshake failure between components",
+    weight: 7,
+    pattern:
+      /(no such host|temporary failure in name resolution|tls handshake timeout|x509|certificate verify failed|unknown certificate authority|ssl routines|handshake failure)/i,
+    nextChecks: [
+      "Resolve hostname from the proxy runtime environment.",
+      "Validate certificate chain, SAN, and system trust store.",
+      "Run: openssl s_client -connect <host:port> -servername <host>"
+    ],
+    possibleFixes: [
+      "Fix DNS records or container network DNS settings.",
+      "Replace/renew invalid certificates and correct SAN names.",
+      "Install proper CA bundle in runtime image."
+    ]
+  },
+  {
+    id: "db_dependency_pressure",
+    title: "Database or dependency latency causing upstream failure",
+    weight: 7,
+    pattern:
+      /(too many connections|could not connect to server|connection pool exhausted|lock wait timeout|deadlock found|query timeout|timeout expired|redis timeout|i\/o timeout)/i,
+    nextChecks: [
+      "Check DB/Redis connection pool saturation and slow query logs.",
+      "Measure dependency latency and error rate during incident window.",
+      "Run: EXPLAIN ANALYZE on top slow query if applicable."
+    ],
+    possibleFixes: [
+      "Add indexes or query rewrites for hot paths.",
+      "Tune pool size with server capacity constraints.",
+      "Introduce retries with jitter only for idempotent operations."
+    ]
+  }
+];
+
+function normalizeLines(input) {
+  return input
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+}
+
+function summarizeConfidence(matches, score) {
+  if (matches >= 3 || score >= 24) {
+    return "high";
+  }
+  if (matches >= 2 || score >= 12) {
+    return "medium";
+  }
+  return "low";
+}
+
+export function analyzeIncident(input, options = {}) {
+  const maxEvidence = Number.isInteger(options.maxEvidence) && options.maxEvidence > 0
+    ? options.maxEvidence
+    : 3;
+
+  const lines = normalizeLines(input);
+  const signalMap = new Map();
+  let matchedLineCount = 0;
+
+  for (const line of lines) {
+    let lineMatched = false;
+
+    for (const rule of RULES) {
+      if (!rule.pattern.test(line)) {
+        continue;
+      }
+
+      lineMatched = true;
+      const existing = signalMap.get(rule.id) || {
+        id: rule.id,
+        title: rule.title,
+        score: 0,
+        matches: 0,
+        evidence: [],
+        nextChecks: rule.nextChecks,
+        possibleFixes: rule.possibleFixes
+      };
+
+      existing.matches += 1;
+      existing.score += rule.weight;
+
+      if (existing.evidence.length < maxEvidence && !existing.evidence.includes(line)) {
+        existing.evidence.push(line);
+      }
+
+      signalMap.set(rule.id, existing);
+    }
+
+    if (lineMatched) {
+      matchedLineCount += 1;
+    }
+  }
+
+  const signals = [...signalMap.values()]
+    .map((signal) => ({
+      ...signal,
+      confidence: summarizeConfidence(signal.matches, signal.score)
+    }))
+    .sort((a, b) => {
+      if (b.score !== a.score) {
+        return b.score - a.score;
+      }
+      if (b.matches !== a.matches) {
+        return b.matches - a.matches;
+      }
+      return a.id.localeCompare(b.id);
+    });
+
+  return {
+    lineCount: lines.length,
+    matchedLineCount,
+    unmatchedLineCount: Math.max(lines.length - matchedLineCount, 0),
+    signals,
+    baselineChecklist: [
+      "Reproduce against upstream directly (bypass proxy) to isolate gateway vs app layer.",
+      "Align proxy and application logs by UTC timestamp for the same failing request.",
+      "Diff latest deploy: image tag, env vars, secrets, and upstream endpoint settings.",
+      "Validate health endpoint behavior and one safe rollback path before high-risk changes."
+    ]
+  };
+}

package/src/output.js

@@ -0,0 +1,43 @@
+function formatSignal(signal, index) {
+  const evidenceLines = signal.evidence.map((line) => `    - ${line}`);
+  const checks = signal.nextChecks.map((line) => `    - ${line}`);
+  const fixes = signal.possibleFixes.map((line) => `    - ${line}`);
+
+  return [
+    `${index + 1}. ${signal.title}`,
+    `   score: ${signal.score} | matches: ${signal.matches} | confidence: ${signal.confidence}`,
+    "   evidence:",
+    ...evidenceLines,
+    "   next checks:",
+    ...checks,
+    "   possible fixes:",
+    ...fixes
+  ].join("\n");
+}
+
+export function formatTextReport(result) {
+  const header = [
+    "Fast Ops Fix - Incident First Response",
+    `input lines: ${result.lineCount}`,
+    `matched lines: ${result.matchedLineCount}`,
+    ""
+  ];
+
+  if (result.signals.length === 0) {
+    return [
+      ...header,
+      "No strong known incident signatures detected.",
+      "Run baseline checks:",
+      ...result.baselineChecklist.map((item) => `- ${item}`)
+    ].join("\n");
+  }
+
+  return [
+    ...header,
+    "Prioritized signals:",
+    ...result.signals.map((signal, index) => formatSignal(signal, index)),
+    "",
+    "Baseline checks:",
+    ...result.baselineChecklist.map((item) => `- ${item}`)
+  ].join("\n");
+}