mergen-server 1.4.0

package/dist/datadog/memory-store.js

@@ -0,0 +1,399 @@
+import initSqlJs from "sql.js";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import { DATA_DIR } from "../sensor/paths.js";
+import logger from "../sensor/logger.js";
+const MEMORY_DB = path.join(DATA_DIR, "incident-memory.db");
+const DEFAULT_CAUSALITY_WINDOW_MS = (() => {
+  const minutes = parseInt(process.env.MERGEN_CAUSALITY_WINDOW_MIN ?? "30", 10);
+  return (Number.isFinite(minutes) ? Math.min(Math.max(minutes, 5), 120) : 30) * 6e4;
+})();
+class IncidentMemoryStore {
+  db = null;
+  isWriting = false;
+  pendingWrite = false;
+  nextBuffer = null;
+  resolveWasmPath() {
+    if (process.env.MERGEN_WASM_PATH) return process.env.MERGEN_WASM_PATH;
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const fromModule = path.resolve(moduleDir, "../../../node_modules/sql.js/dist/sql-wasm.wasm");
+    if (fs.existsSync(fromModule)) return fromModule;
+    try {
+      const req = createRequire(import.meta.url);
+      const resolved = path.join(path.dirname(req.resolve("sql.js")), "sql-wasm.wasm");
+      if (fs.existsSync(resolved)) return resolved;
+    } catch {
+    }
+    return fromModule;
+  }
+  async init() {
+    try {
+      const wasmBinary = fs.readFileSync(this.resolveWasmPath());
+      const SQL = await initSqlJs({ wasmBinary });
+      fs.mkdirSync(DATA_DIR, { recursive: true });
+      let buf;
+      if (fs.existsSync(MEMORY_DB)) {
+        try {
+          buf = fs.readFileSync(MEMORY_DB);
+        } catch {
+        }
+      }
+      this.db = buf ? new SQL.Database(buf) : new SQL.Database();
+      this.db.run(`
+        CREATE TABLE IF NOT EXISTS incident_memory (
+          id                INTEGER PRIMARY KEY AUTOINCREMENT,
+          fingerprint       TEXT    NOT NULL,
+          service           TEXT    NOT NULL,
+          endpoint          TEXT    NOT NULL,
+          error_type        TEXT    NOT NULL DEFAULT '',
+          error_message     TEXT    NOT NULL DEFAULT '',
+          implicated_file   TEXT,
+          implicated_line   INTEGER,
+          deployed_sha      TEXT,
+          fired_at          INTEGER NOT NULL,
+          resolved_at       INTEGER,
+          mttr_ms           INTEGER,
+          pd_incident_id    TEXT,
+          pd_alert_title    TEXT    NOT NULL DEFAULT '',
+          pd_alert_url      TEXT,
+          trace_id          TEXT    NOT NULL DEFAULT '',
+          fix_pr_url        TEXT,
+          fix_pr_title      TEXT,
+          fix_pr_sha        TEXT,
+          fix_summary       TEXT,
+          resolution_type   TEXT    NOT NULL DEFAULT 'unknown',
+          raw_fact          TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_mem_fingerprint ON incident_memory(fingerprint);
+        CREATE INDEX IF NOT EXISTS idx_mem_fired_at    ON incident_memory(fired_at);
+        CREATE INDEX IF NOT EXISTS idx_mem_service     ON incident_memory(service);
+
+        CREATE TABLE IF NOT EXISTS incident_benchmarks (
+          id               INTEGER PRIMARY KEY AUTOINCREMENT,
+          fingerprint      TEXT    NOT NULL,
+          mttr_ms          INTEGER,
+          resolution_type  TEXT    NOT NULL DEFAULT 'unknown',
+          recorded_at      INTEGER NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_bench_fingerprint ON incident_benchmarks(fingerprint);
+      `);
+      for (const col of [
+        "ALTER TABLE incident_memory ADD COLUMN attribution_confidence REAL",
+        "ALTER TABLE incident_memory ADD COLUMN attribution_sha TEXT",
+        "ALTER TABLE incident_memory ADD COLUMN attribution_validated INTEGER"
+      ]) {
+        try {
+          this.db.run(col);
+        } catch {
+        }
+      }
+      this._flush();
+      logger.info({ path: MEMORY_DB }, "incident memory store initialised");
+    } catch (err) {
+      logger.warn({ err }, "incident memory store failed to init");
+    }
+  }
+  // ── Write ──────────────────────────────────────────────────────────────────
+  openIncident(fields) {
+    if (!this.db) return -1;
+    this.db.run(
+      `INSERT INTO incident_memory
+         (fingerprint, service, endpoint, error_type, error_message,
+          implicated_file, implicated_line, deployed_sha,
+          fired_at, pd_incident_id, pd_alert_title, pd_alert_url,
+          trace_id, raw_fact, attribution_confidence, attribution_sha)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+      [
+        fields.fingerprint,
+        fields.service,
+        fields.endpoint,
+        fields.errorType,
+        fields.errorMessage,
+        fields.implicatedFile ?? null,
+        fields.implicatedLine ?? null,
+        fields.deployedSha ?? null,
+        fields.firedAt ?? Date.now(),
+        fields.pdIncidentId ?? null,
+        fields.pdAlertTitle,
+        fields.pdAlertUrl ?? null,
+        fields.traceId,
+        fields.rawFact ?? null,
+        fields.attributionConfidence ?? null,
+        fields.attributionSha ?? null
+      ]
+    );
+    const idRes = this.db.exec("SELECT last_insert_rowid()");
+    const id = idRes[0]?.values[0]?.[0] ?? -1;
+    this._flush();
+    return id;
+  }
+  closeIncident(opts) {
+    if (!this.db) return;
+    const resolvedAt = opts.resolvedAt ?? Date.now();
+    const resolutionType = opts.resolutionType ?? "unknown";
+    const openRec = opts.id ? this.db.exec(
+      "SELECT id, fired_at, fingerprint FROM incident_memory WHERE id = ? AND resolved_at IS NULL LIMIT 1",
+      [opts.id]
+    ) : this.db.exec(
+      "SELECT id, fired_at, fingerprint FROM incident_memory WHERE pd_incident_id = ? AND resolved_at IS NULL LIMIT 1",
+      [opts.pdIncidentId ?? null]
+    );
+    if (!openRec[0]?.values?.length) return;
+    const [recId, firedAt, fingerprint] = openRec[0].values[0];
+    const mttrMs = resolvedAt - firedAt;
+    let attributionValidated = null;
+    if (opts.fixPrSha) {
+      const attrRes = this.db.exec(
+        "SELECT attribution_sha FROM incident_memory WHERE id = ?",
+        [recId]
+      );
+      const attrSha = attrRes[0]?.values[0]?.[0];
+      if (attrSha && opts.fixPrSha) {
+        attributionValidated = opts.fixPrSha.startsWith(attrSha) || attrSha.startsWith(opts.fixPrSha) ? 1 : 0;
+        logger.info({ recId, attributionValidated }, "attribution accuracy recorded");
+      }
+    }
+    this.db.run(
+      `UPDATE incident_memory
+       SET resolved_at=?, mttr_ms=?, fix_pr_url=?, fix_pr_title=?, fix_pr_sha=?,
+           fix_summary=?, resolution_type=?, attribution_validated=?
+       WHERE id=?`,
+      [
+        resolvedAt,
+        mttrMs,
+        opts.fixPrUrl ?? null,
+        opts.fixPrTitle ?? null,
+        opts.fixPrSha ?? null,
+        opts.fixSummary ?? null,
+        resolutionType,
+        attributionValidated,
+        recId
+      ]
+    );
+    this.db.run(
+      "INSERT INTO incident_benchmarks (fingerprint, mttr_ms, resolution_type, recorded_at) VALUES (?,?,?,?)",
+      [fingerprint, mttrMs, resolutionType, resolvedAt]
+    );
+    this._flush();
+  }
+  // Called by GitHub webhook: find the most recent open incident and correlate
+  correlateGitHubPR(opts) {
+    if (!this.db) return;
+    const windowStart = opts.mergedAt - DEFAULT_CAUSALITY_WINDOW_MS;
+    const res = this.db.exec(
+      `SELECT id FROM incident_memory
+       WHERE resolved_at IS NULL AND fired_at >= ?
+       ORDER BY fired_at DESC LIMIT 1`,
+      [windowStart]
+    );
+    if (!res[0]?.values?.length) return;
+    const [id] = res[0].values[0];
+    const type = inferResolutionType(opts.prTitle);
+    this.db.run(
+      `UPDATE incident_memory
+       SET fix_pr_url=?, fix_pr_title=?, fix_pr_sha=?, resolution_type=?
+       WHERE id=?`,
+      [opts.prUrl, opts.prTitle, opts.prSha, type, id]
+    );
+    this._flush();
+    logger.info({ id, prUrl: opts.prUrl, type }, "github PR correlated to open incident");
+  }
+  // ── Read ───────────────────────────────────────────────────────────────────
+  findSimilar(fingerprint, limit = 5) {
+    if (!this.db) return [];
+    const res = this.db.exec(
+      `SELECT * FROM incident_memory WHERE fingerprint=? ORDER BY fired_at DESC LIMIT ?`,
+      [fingerprint, limit]
+    );
+    return this._rows(res);
+  }
+  benchmarkStats(fingerprint) {
+    if (!this.db) return null;
+    const res = this.db.exec(
+      `SELECT mttr_ms, resolution_type FROM incident_benchmarks WHERE fingerprint=? ORDER BY recorded_at DESC LIMIT 100`,
+      [fingerprint]
+    );
+    if (!res[0]?.values?.length) return null;
+    const rows = res[0].values;
+    const mttrValues = rows.map((r) => r[0]).filter((v) => v !== null).sort((a, b) => a - b);
+    const typeCounts = {};
+    for (const [, t] of rows) typeCounts[t] = (typeCounts[t] ?? 0) + 1;
+    const topEntry = Object.entries(typeCounts).sort((a, b) => b[1] - a[1])[0];
+    const lastRes = this.db.exec(
+      `SELECT MAX(recorded_at) FROM incident_benchmarks WHERE fingerprint=?`,
+      [fingerprint]
+    );
+    const lastSeenAt = lastRes[0]?.values[0]?.[0] ?? null;
+    return {
+      fingerprint,
+      occurrences: rows.length,
+      p50MttrMs: mttrValues.length ? mttrValues[Math.floor(mttrValues.length * 0.5)] : null,
+      p90MttrMs: mttrValues.length ? mttrValues[Math.floor(mttrValues.length * 0.9)] : null,
+      topResolutionType: topEntry?.[0] ?? "unknown",
+      topResolutionCount: topEntry?.[1] ?? 0,
+      lastSeenAt
+    };
+  }
+  listOpen() {
+    if (!this.db) return [];
+    const res = this.db.exec(
+      "SELECT * FROM incident_memory WHERE resolved_at IS NULL ORDER BY fired_at DESC LIMIT 20"
+    );
+    return this._rows(res);
+  }
+  listAll(limit = 100) {
+    if (!this.db) return [];
+    const res = this.db.exec(
+      "SELECT * FROM incident_memory ORDER BY fired_at DESC LIMIT ?",
+      [limit]
+    );
+    return this._rows(res);
+  }
+  /** Store explicit attribution feedback from `mergen-server resolved` prompt. */
+  recordAttributionFeedback(id, validated) {
+    if (!this.db) return;
+    this.db.run(
+      "UPDATE incident_memory SET attribution_validated = ? WHERE id = ?",
+      [validated, id]
+    );
+    this._flush();
+    logger.info({ id, validated }, "attribution feedback stored");
+  }
+  /** Find recent incidents (open or resolved) that implicate a specific file path. */
+  findByFile(filePath, limit = 10) {
+    if (!this.db) return [];
+    const basename = filePath.split("/").pop() ?? filePath;
+    const res = this.db.exec(
+      `SELECT * FROM incident_memory
+       WHERE implicated_file LIKE ? OR implicated_file LIKE ?
+       ORDER BY fired_at DESC LIMIT ?`,
+      [`%${basename}`, `%${filePath}%`, limit]
+    );
+    return this._rows(res);
+  }
+  /** Returns per-service stats: incident count, avg MTTR, most recent. */
+  serviceStats(service) {
+    if (!this.db) return { count: 0, avgMttrMs: null, lastFiredAt: null };
+    const res = this.db.exec(
+      `SELECT COUNT(*) as cnt, AVG(mttr_ms) as avg_mttr, MAX(fired_at) as last
+       FROM incident_memory WHERE service = ?`,
+      [service]
+    );
+    const row = res[0]?.values[0];
+    if (!row) return { count: 0, avgMttrMs: null, lastFiredAt: null };
+    return {
+      count: Number(row[0] ?? 0),
+      avgMttrMs: row[1] ? Number(row[1]) : null,
+      lastFiredAt: row[2] ? Number(row[2]) : null
+    };
+  }
+  getById(id) {
+    if (!this.db) return null;
+    const res = this.db.exec("SELECT * FROM incident_memory WHERE id=?", [id]);
+    const rows = this._rows(res);
+    return rows[0] ?? null;
+  }
+  // ── Internal ───────────────────────────────────────────────────────────────
+  _rows(res) {
+    if (!res[0]?.values) return [];
+    const cols = res[0].columns;
+    return res[0].values.map((vals) => {
+      const r = {};
+      cols.forEach((c, i) => {
+        r[c] = vals[i];
+      });
+      return {
+        id: r.id,
+        fingerprint: String(r.fingerprint ?? ""),
+        service: String(r.service ?? ""),
+        endpoint: String(r.endpoint ?? ""),
+        errorType: String(r.error_type ?? ""),
+        errorMessage: String(r.error_message ?? ""),
+        implicatedFile: r.implicated_file ? String(r.implicated_file) : null,
+        implicatedLine: r.implicated_line ? Number(r.implicated_line) : null,
+        deployedSha: r.deployed_sha ? String(r.deployed_sha) : null,
+        firedAt: Number(r.fired_at ?? 0),
+        resolvedAt: r.resolved_at ? Number(r.resolved_at) : null,
+        mttrMs: r.mttr_ms ? Number(r.mttr_ms) : null,
+        pdIncidentId: r.pd_incident_id ? String(r.pd_incident_id) : null,
+        pdAlertTitle: String(r.pd_alert_title ?? ""),
+        pdAlertUrl: r.pd_alert_url ? String(r.pd_alert_url) : null,
+        traceId: String(r.trace_id ?? ""),
+        fixPrUrl: r.fix_pr_url ? String(r.fix_pr_url) : null,
+        fixPrTitle: r.fix_pr_title ? String(r.fix_pr_title) : null,
+        fixPrSha: r.fix_pr_sha ? String(r.fix_pr_sha) : null,
+        fixSummary: r.fix_summary ? String(r.fix_summary) : null,
+        resolutionType: r.resolution_type ?? "unknown",
+        rawFact: r.raw_fact ? String(r.raw_fact) : null,
+        attributionConfidence: r.attribution_confidence ? Number(r.attribution_confidence) : null,
+        attributionSha: r.attribution_sha ? String(r.attribution_sha) : null,
+        attributionValidated: r.attribution_validated != null ? Number(r.attribution_validated) : null
+      };
+    });
+  }
+  /** Returns true when the SQLite database initialised successfully. */
+  isHealthy() {
+    return this.db !== null;
+  }
+  _flush() {
+    if (!this.db) return;
+    try {
+      const data = this.db.export();
+      this._writeBufferAsync(Buffer.from(data.buffer, data.byteOffset, data.byteLength));
+    } catch (err) {
+      logger.warn({ err }, "memory store flush failed");
+    }
+  }
+  _writeBufferAsync(buf) {
+    if (this.isWriting) {
+      this.pendingWrite = true;
+      this.nextBuffer = buf;
+      return;
+    }
+    this.isWriting = true;
+    const tmp = `${MEMORY_DB}.tmp.${process.pid}`;
+    fs.writeFile(tmp, buf, (err) => {
+      if (err) {
+        logger.warn({ err }, "memory store async write failed");
+        this.isWriting = false;
+        this._processPendingWrite();
+        return;
+      }
+      fs.rename(tmp, MEMORY_DB, (renameErr) => {
+        if (renameErr) logger.warn({ err: renameErr }, "memory store async rename failed");
+        this.isWriting = false;
+        this._processPendingWrite();
+      });
+    });
+  }
+  _processPendingWrite() {
+    if (this.pendingWrite && this.nextBuffer) {
+      this.pendingWrite = false;
+      const buf = this.nextBuffer;
+      this.nextBuffer = null;
+      this._writeBufferAsync(buf);
+    }
+  }
+}
+function inferResolutionType(prTitle) {
+  const t = prTitle.toLowerCase();
+  if (/revert|rollback|undo/.test(t)) return "rollback_deploy";
+  if (/flag|feature.flag|toggle|launch.darkly|launchdarkly/.test(t)) return "flag_rollback";
+  if (/config|env|setting|secret|credential/.test(t)) return "config_change";
+  if (/fix|patch|hotfix|bug|crash|error|incident/.test(t)) return "hotfix_deploy";
+  return "unknown";
+}
+function formatMttr(ms) {
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+  if (ms < 36e5) return `${Math.round(ms / 6e4)}m`;
+  return `${(ms / 36e5).toFixed(1)}h`;
+}
+const memoryStore = new IncidentMemoryStore();
+export {
+  DEFAULT_CAUSALITY_WINDOW_MS,
+  formatMttr,
+  inferResolutionType,
+  memoryStore
+};

package/dist/datadog/otel-trace.js

@@ -0,0 +1,67 @@
+import crypto from "crypto";
+const SESSION_TRACE_ID = crypto.randomBytes(16).toString("hex");
+let _traceId = SESSION_TRACE_ID;
+let _spanId = crypto.randomBytes(8).toString("hex");
+function startServerSpan(incomingTraceparent) {
+  if (incomingTraceparent) {
+    const parsed = parseTraceparent(incomingTraceparent);
+    if (parsed) {
+      _traceId = parsed.traceId;
+      _spanId = crypto.randomBytes(8).toString("hex");
+      return build();
+    }
+  }
+  _spanId = crypto.randomBytes(8).toString("hex");
+  return build();
+}
+function startClientSpan() {
+  const childSpan = crypto.randomBytes(8).toString("hex");
+  return {
+    traceId: _traceId,
+    spanId: childSpan,
+    traceparent: `00-${_traceId}-${childSpan}-01`
+  };
+}
+function getCurrentTraceContext() {
+  return build();
+}
+function extractTraceparentFromMeta(meta) {
+  if (!meta) return null;
+  if (typeof meta["traceparent"] === "string") return meta["traceparent"];
+  const tc = meta["traceContext"];
+  if (typeof tc?.["traceparent"] === "string") return tc["traceparent"];
+  return null;
+}
+function parseTraceparent(tp) {
+  const parts = tp.split("-");
+  if (parts.length < 4) return null;
+  const [version, traceId, spanId, flags] = parts;
+  if (version !== "00") return null;
+  if (!/^[0-9a-f]{32}$/.test(traceId)) return null;
+  if (!/^[0-9a-f]{16}$/.test(spanId)) return null;
+  return { traceId, spanId, flags: flags ?? "01" };
+}
+function buildMetaTraceContext() {
+  const ctx = build();
+  return {
+    traceContext: {
+      traceparent: ctx.traceparent
+      // tracestate intentionally omitted unless we have vendor-specific state
+    }
+  };
+}
+function build() {
+  return {
+    traceId: _traceId,
+    spanId: _spanId,
+    traceparent: `00-${_traceId}-${_spanId}-01`
+  };
+}
+export {
+  buildMetaTraceContext,
+  extractTraceparentFromMeta,
+  getCurrentTraceContext,
+  parseTraceparent,
+  startClientSpan,
+  startServerSpan
+};