@thotischner/observability-mcp 1.0.0

package/dist/config/loader.test.js

@@ -0,0 +1,163 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { writeFileSync, mkdirSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+// We test the helper functions by importing the module fresh with different env vars.
+// Since the config path is resolved at import time, we use dynamic imports.
+const TMP_DIR = join(tmpdir(), "observability-mcp-test-" + Date.now());
+describe("config/loader", () => {
+    beforeEach(() => {
+        mkdirSync(TMP_DIR, { recursive: true });
+    });
+    afterEach(() => {
+        rmSync(TMP_DIR, { recursive: true, force: true });
+        delete process.env.CONFIG_PATH;
+        delete process.env.PROMETHEUS_URL;
+        delete process.env.LOKI_URL;
+    });
+    describe("loadConfig with CONFIG_PATH", () => {
+        it("loads sources from YAML file", async () => {
+            const configPath = join(TMP_DIR, "sources.yaml");
+            writeFileSync(configPath, `
+sources:
+  - name: prom1
+    type: prometheus
+    url: http://localhost:9090
+    enabled: true
+`);
+            process.env.CONFIG_PATH = configPath;
+            // Dynamic import to pick up new env
+            const mod = await import("./loader.js?" + Date.now());
+            // loadConfig is already called at module level for CONFIG_PATH, but we call it again
+            const config = mod.loadConfig();
+            assert.equal(config.sources.length, 1);
+            assert.equal(config.sources[0].name, "prom1");
+            assert.equal(config.sources[0].url, "http://localhost:9090");
+        });
+        it("falls back to env vars when config file does not exist", async () => {
+            process.env.CONFIG_PATH = join(TMP_DIR, "nonexistent.yaml");
+            process.env.PROMETHEUS_URL = "http://p1:9090";
+            process.env.LOKI_URL = "http://l1:3100";
+            const mod = await import("./loader.js?" + Date.now());
+            const config = mod.loadConfig();
+            assert.equal(config.sources.length, 2);
+            assert.equal(config.sources[0].name, "prometheus");
+            assert.equal(config.sources[0].url, "http://p1:9090");
+            assert.equal(config.sources[1].name, "loki");
+            assert.equal(config.sources[1].url, "http://l1:3100");
+        });
+        it("returns empty sources when no config and no env vars", async () => {
+            process.env.CONFIG_PATH = join(TMP_DIR, "nonexistent.yaml");
+            const mod = await import("./loader.js?" + Date.now());
+            const config = mod.loadConfig();
+            assert.equal(config.sources.length, 0);
+        });
+    });
+    describe("env var parsing - comma-separated URLs", () => {
+        it("creates multiple prometheus sources from comma-separated URLs", async () => {
+            process.env.CONFIG_PATH = join(TMP_DIR, "nonexistent.yaml");
+            process.env.PROMETHEUS_URL = "http://p1:9090,http://p2:9090,http://p3:9090";
+            const mod = await import("./loader.js?" + Date.now());
+            const config = mod.loadConfig();
+            assert.equal(config.sources.length, 3);
+            assert.equal(config.sources[0].name, "prometheus-1");
+            assert.equal(config.sources[0].url, "http://p1:9090");
+            assert.equal(config.sources[1].name, "prometheus-2");
+            assert.equal(config.sources[1].url, "http://p2:9090");
+            assert.equal(config.sources[2].name, "prometheus-3");
+            assert.equal(config.sources[2].url, "http://p3:9090");
+        });
+        it("uses plain name for single URL (no suffix)", async () => {
+            process.env.CONFIG_PATH = join(TMP_DIR, "nonexistent.yaml");
+            process.env.PROMETHEUS_URL = "http://p1:9090";
+            const mod = await import("./loader.js?" + Date.now());
+            const config = mod.loadConfig();
+            assert.equal(config.sources.length, 1);
+            assert.equal(config.sources[0].name, "prometheus");
+        });
+        it("trims whitespace from URLs", async () => {
+            process.env.CONFIG_PATH = join(TMP_DIR, "nonexistent.yaml");
+            process.env.LOKI_URL = " http://l1:3100 , http://l2:3100 ";
+            const mod = await import("./loader.js?" + Date.now());
+            const config = mod.loadConfig();
+            assert.equal(config.sources.length, 2);
+            assert.equal(config.sources[0].url, "http://l1:3100");
+            assert.equal(config.sources[1].url, "http://l2:3100");
+        });
+        it("combines prometheus and loki sources", async () => {
+            process.env.CONFIG_PATH = join(TMP_DIR, "nonexistent.yaml");
+            process.env.PROMETHEUS_URL = "http://p1:9090,http://p2:9090";
+            process.env.LOKI_URL = "http://l1:3100";
+            const mod = await import("./loader.js?" + Date.now());
+            const config = mod.loadConfig();
+            assert.equal(config.sources.length, 3);
+            assert.equal(config.sources[0].name, "prometheus-1");
+            assert.equal(config.sources[1].name, "prometheus-2");
+            assert.equal(config.sources[2].name, "loki");
+        });
+    });
+    describe("saveConfig", () => {
+        it("creates directory and writes YAML file", async () => {
+            const configPath = join(TMP_DIR, "sub", "dir", "sources.yaml");
+            process.env.CONFIG_PATH = configPath;
+            const mod = await import("./loader.js?" + Date.now());
+            const config = mod.loadConfig();
+            config.sources.push({ name: "test", type: "prometheus", url: "http://test:9090", enabled: true });
+            mod.saveConfig(config);
+            assert.ok(existsSync(configPath));
+            // Re-load and verify
+            const reloaded = mod.loadConfig();
+            assert.equal(reloaded.sources.length, 1);
+            assert.equal(reloaded.sources[0].name, "test");
+        });
+    });
+    describe("default settings", () => {
+        it("has correct defaults", async () => {
+            process.env.CONFIG_PATH = join(TMP_DIR, "nonexistent.yaml");
+            const mod = await import("./loader.js?" + Date.now());
+            const config = mod.loadConfig();
+            assert.equal(config.settings.checkIntervalMs, 30000);
+            assert.equal(config.settings.defaultSensitivity, "medium");
+        });
+        it("has correct default health thresholds", async () => {
+            process.env.CONFIG_PATH = join(TMP_DIR, "nonexistent.yaml");
+            const mod = await import("./loader.js?" + Date.now());
+            const config = mod.loadConfig();
+            assert.equal(config.healthThresholds.weights.errorRate, 0.35);
+            assert.equal(config.healthThresholds.cpu.crit, 95);
+            assert.equal(config.healthThresholds.statusBoundaries.healthy, 80);
+        });
+    });
+    describe("config merging", () => {
+        it("merges partial settings with defaults", async () => {
+            const configPath = join(TMP_DIR, "partial.yaml");
+            writeFileSync(configPath, `
+sources: []
+settings:
+  checkIntervalMs: 60000
+`);
+            process.env.CONFIG_PATH = configPath;
+            const mod = await import("./loader.js?" + Date.now());
+            const config = mod.loadConfig();
+            assert.equal(config.settings.checkIntervalMs, 60000);
+            assert.equal(config.settings.defaultSensitivity, "medium"); // default preserved
+        });
+        it("deep-merges health thresholds", async () => {
+            const configPath = join(TMP_DIR, "thresholds.yaml");
+            writeFileSync(configPath, `
+sources: []
+healthThresholds:
+  cpu:
+    crit: 99
+`);
+            process.env.CONFIG_PATH = configPath;
+            const mod = await import("./loader.js?" + Date.now());
+            const config = mod.loadConfig();
+            assert.equal(config.healthThresholds.cpu.crit, 99); // overridden
+            assert.equal(config.healthThresholds.cpu.good, 50); // default preserved
+            assert.equal(config.healthThresholds.cpu.warn, 80); // default preserved
+            assert.equal(config.healthThresholds.weights.errorRate, 0.35); // other sections preserved
+        });
+    });
+});

package/dist/connectors/interface.d.ts

@@ -0,0 +1,17 @@
+import type { SignalType, ConnectorHealth, ServiceInfo, MetricInfo, MetricQuery, MetricResult, LogQuery, LogResult, SourceConfig, MetricDefinition } from "../types.js";
+export interface ObservabilityConnector {
+    readonly name: string;
+    readonly type: string;
+    readonly signalType: SignalType;
+    connect(config: SourceConfig): Promise<void>;
+    healthCheck(): Promise<ConnectorHealth>;
+    disconnect(): Promise<void>;
+    /** Returns the default metric definitions for this connector type */
+    getDefaultMetrics(): MetricDefinition[];
+    /** Returns the active metrics (user-configured or defaults) */
+    getMetrics(): MetricDefinition[];
+    listServices(): Promise<ServiceInfo[]>;
+    listAvailableMetrics?(service: string): Promise<MetricInfo[]>;
+    queryMetrics?(params: MetricQuery): Promise<MetricResult>;
+    queryLogs?(params: LogQuery): Promise<LogResult>;
+}

package/dist/connectors/interface.js

@@ -0,0 +1 @@
+export {};

package/dist/connectors/loki.d.ts

@@ -0,0 +1,25 @@
+import type { ObservabilityConnector } from "./interface.js";
+import type { SourceConfig, ConnectorHealth, ServiceInfo, MetricDefinition, LogQuery, LogResult, SignalType } from "../types.js";
+export declare class LokiConnector implements ObservabilityConnector {
+    readonly type = "loki";
+    readonly signalType: SignalType;
+    name: string;
+    private baseUrl;
+    private auth?;
+    private tlsAgent?;
+    connect(config: SourceConfig): Promise<void>;
+    getDefaultMetrics(): MetricDefinition[];
+    getMetrics(): MetricDefinition[];
+    private fetchOptions;
+    healthCheck(): Promise<ConnectorHealth>;
+    disconnect(): Promise<void>;
+    listServices(): Promise<ServiceInfo[]>;
+    queryLogs(params: LogQuery): Promise<LogResult>;
+    private parseLine;
+    private extractTopPatterns;
+    private parseTimeRange;
+    private escapeLogQLValue;
+    private escapeLogQLRegex;
+    private buildAuthHeaders;
+    private apiGet;
+}

package/dist/connectors/loki.js

@@ -0,0 +1,182 @@
+import { buildTlsAgent } from "./tls.js";
+export class LokiConnector {
+    type = "loki";
+    signalType = "logs";
+    name = "";
+    baseUrl = "";
+    auth;
+    tlsAgent;
+    async connect(config) {
+        this.name = config.name;
+        this.baseUrl = config.url.replace(/\/$/, "");
+        this.auth = config.auth;
+        this.tlsAgent = buildTlsAgent(config);
+    }
+    getDefaultMetrics() {
+        // Loki is a log backend — no metric definitions by default
+        return [];
+    }
+    getMetrics() {
+        return [];
+    }
+    fetchOptions() {
+        const opts = { headers: this.buildAuthHeaders() };
+        if (this.tlsAgent) {
+            // @ts-expect-error Node.js extension for native fetch
+            opts.dispatcher = this.tlsAgent;
+        }
+        return opts;
+    }
+    async healthCheck() {
+        const start = Date.now();
+        try {
+            const res = await fetch(`${this.baseUrl}/ready`, this.fetchOptions());
+            const text = await res.text();
+            const isReady = res.ok && text.trim() === "ready";
+            return {
+                status: isReady ? "up" : "down",
+                latencyMs: Date.now() - start,
+                message: isReady ? "Loki is ready" : `HTTP ${res.status}: ${text}`,
+            };
+        }
+        catch (err) {
+            return { status: "down", latencyMs: Date.now() - start, message: String(err) };
+        }
+    }
+    async disconnect() { }
+    async listServices() {
+        try {
+            const data = await this.apiGet("/loki/api/v1/label/service/values");
+            return (data?.data || []).map((name) => ({
+                name,
+                source: this.name,
+                signalType: "logs",
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async queryLogs(params) {
+        const { start, end } = this.parseTimeRange(params.duration);
+        const limit = Math.min(Math.max(params.limit || 100, 1), 1000);
+        const service = this.escapeLogQLValue(params.service);
+        let logql = `{service="${service}"}`;
+        if (params.level) {
+            const level = this.escapeLogQLValue(params.level);
+            logql += ` | json | level="${level}"`;
+        }
+        else {
+            logql += ` | json`;
+        }
+        if (params.query) {
+            const query = this.escapeLogQLRegex(params.query);
+            logql += ` |~ \`${query}\``;
+        }
+        const url = `/loki/api/v1/query_range?query=${encodeURIComponent(logql)}` +
+            `&start=${start}000000000&end=${end}000000000&limit=${limit}`;
+        const data = await this.apiGet(url);
+        const entries = [];
+        for (const stream of data?.data?.result || []) {
+            const labels = stream.stream;
+            for (const [ts, line] of stream.values) {
+                const parsed = this.parseLine(line);
+                entries.push({
+                    timestamp: new Date(parseInt(ts) / 1_000_000).toISOString(),
+                    level: parsed.level || labels.level || "unknown",
+                    message: parsed.msg || line,
+                    labels,
+                });
+            }
+        }
+        // Sort newest first
+        entries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+        // Compute summary
+        const errorCount = entries.filter((e) => e.level === "error").length;
+        const warnCount = entries.filter((e) => e.level === "warn").length;
+        const topPatterns = this.extractTopPatterns(entries.filter((e) => e.level === "error"));
+        return {
+            source: this.name,
+            service: params.service,
+            entries,
+            summary: {
+                total: entries.length,
+                errorCount,
+                warnCount,
+                topPatterns,
+            },
+        };
+    }
+    // --- Private helpers ---
+    parseLine(line) {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return { msg: line };
+        }
+    }
+    extractTopPatterns(errorEntries) {
+        const patterns = new Map();
+        for (const entry of errorEntries) {
+            // Use first 100 chars of message as pattern key
+            const key = entry.message.slice(0, 100);
+            patterns.set(key, (patterns.get(key) || 0) + 1);
+        }
+        return Array.from(patterns.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([pattern, count]) => `${pattern} (${count}x)`);
+    }
+    parseTimeRange(duration) {
+        const now = Math.floor(Date.now() / 1000);
+        const match = duration.match(/^(\d+)([mhd])$/);
+        if (!match)
+            throw new Error(`Invalid duration: ${duration}`);
+        const value = parseInt(match[1]);
+        const unit = match[2];
+        const seconds = unit === "m" ? value * 60 : unit === "h" ? value * 3600 : value * 86400;
+        return { start: now - seconds, end: now };
+    }
+    escapeLogQLValue(value) {
+        return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    }
+    escapeLogQLRegex(value) {
+        // Escape backticks which would break the LogQL regex delimiter
+        return value.replace(/`/g, "\\`");
+    }
+    buildAuthHeaders() {
+        if (!this.auth || this.auth.type === "none")
+            return {};
+        if (this.auth.type === "bearer" && this.auth.token) {
+            return { Authorization: `Bearer ${this.auth.token}` };
+        }
+        if (this.auth.type === "basic" && this.auth.username) {
+            const encoded = Buffer.from(`${this.auth.username}:${this.auth.password || ""}`).toString("base64");
+            return { Authorization: `Basic ${encoded}` };
+        }
+        return {};
+    }
+    async apiGet(path, timeoutMs = 10000) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(`${this.baseUrl}${path}`, {
+                ...this.fetchOptions(),
+                signal: controller.signal,
+            });
+            if (!res.ok)
+                throw new Error(`Loki API error: ${res.status} ${res.statusText}`);
+            return res.json();
+        }
+        catch (err) {
+            if (err instanceof DOMException && err.name === "AbortError") {
+                throw new Error(`Loki query timed out after ${timeoutMs}ms`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}

package/dist/connectors/loki.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/connectors/loki.test.js

@@ -0,0 +1,111 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { LokiConnector } from "./loki.js";
+const proto = LokiConnector.prototype;
+describe("LokiConnector", () => {
+    describe("parseLine", () => {
+        it("parses valid JSON", () => {
+            const result = proto.parseLine('{"level":"error","msg":"timeout"}');
+            assert.equal(result.level, "error");
+            assert.equal(result.msg, "timeout");
+        });
+        it("returns msg wrapper for invalid JSON", () => {
+            const result = proto.parseLine("plain text log line");
+            assert.equal(result.msg, "plain text log line");
+        });
+        it("handles empty string", () => {
+            const result = proto.parseLine("");
+            assert.equal(result.msg, "");
+        });
+        it("parses complex JSON", () => {
+            const result = proto.parseLine('{"level":"info","msg":"ok","nested":{"key":"val"}}');
+            assert.equal(result.level, "info");
+            assert.deepEqual(result.nested, { key: "val" });
+        });
+    });
+    describe("extractTopPatterns", () => {
+        it("returns empty for no entries", () => {
+            assert.deepEqual(proto.extractTopPatterns([]), []);
+        });
+        it("counts duplicate patterns", () => {
+            const entries = [
+                { message: "connection timeout" },
+                { message: "connection timeout" },
+                { message: "connection timeout" },
+                { message: "null pointer" },
+            ];
+            const patterns = proto.extractTopPatterns(entries);
+            assert.equal(patterns.length, 2);
+            assert.ok(patterns[0].includes("connection timeout"));
+            assert.ok(patterns[0].includes("3x"));
+            assert.ok(patterns[1].includes("null pointer"));
+            assert.ok(patterns[1].includes("1x"));
+        });
+        it("limits to top 5 patterns", () => {
+            const entries = [];
+            for (let i = 0; i < 10; i++) {
+                entries.push({ message: `error type ${i}` });
+            }
+            const patterns = proto.extractTopPatterns(entries);
+            assert.equal(patterns.length, 5);
+        });
+        it("sorts by count descending", () => {
+            const entries = [
+                { message: "rare error" },
+                { message: "common error" },
+                { message: "common error" },
+                { message: "common error" },
+            ];
+            const patterns = proto.extractTopPatterns(entries);
+            assert.ok(patterns[0].includes("common error"));
+            assert.ok(patterns[0].includes("3x"));
+        });
+        it("truncates long messages to 100 chars for pattern key", () => {
+            const longMsg = "x".repeat(200);
+            const entries = [{ message: longMsg }, { message: longMsg }];
+            const patterns = proto.extractTopPatterns(entries);
+            assert.equal(patterns.length, 1);
+            assert.ok(patterns[0].includes("2x"));
+        });
+    });
+    describe("parseTimeRange", () => {
+        it("parses minutes", () => {
+            const { start, end } = proto.parseTimeRange("10m");
+            assert.ok(end - start >= 599 && end - start <= 601);
+        });
+        it("parses hours", () => {
+            const { start, end } = proto.parseTimeRange("2h");
+            assert.ok(end - start >= 7199 && end - start <= 7201);
+        });
+        it("parses days", () => {
+            const { start, end } = proto.parseTimeRange("1d");
+            assert.ok(end - start >= 86399 && end - start <= 86401);
+        });
+        it("throws on invalid duration", () => {
+            assert.throws(() => proto.parseTimeRange("invalid"));
+            assert.throws(() => proto.parseTimeRange("5s"));
+        });
+    });
+    describe("escapeLogQLValue", () => {
+        it("returns value unchanged when no escaping needed", () => {
+            assert.equal(proto.escapeLogQLValue("api-gateway"), "api-gateway");
+        });
+        it("escapes backslashes", () => {
+            assert.equal(proto.escapeLogQLValue("path\\to\\file"), "path\\\\to\\\\file");
+        });
+        it("escapes double quotes", () => {
+            assert.equal(proto.escapeLogQLValue('say "hello"'), 'say \\"hello\\"');
+        });
+        it("escapes both", () => {
+            assert.equal(proto.escapeLogQLValue('a\\b"c'), 'a\\\\b\\"c');
+        });
+    });
+    describe("escapeLogQLRegex", () => {
+        it("returns value unchanged when no backticks", () => {
+            assert.equal(proto.escapeLogQLRegex("error.*timeout"), "error.*timeout");
+        });
+        it("escapes backticks", () => {
+            assert.equal(proto.escapeLogQLRegex("error`test`"), "error\\`test\\`");
+        });
+    });
+});

package/dist/connectors/prometheus.d.ts

@@ -0,0 +1,28 @@
+import type { ObservabilityConnector } from "./interface.js";
+import type { SourceConfig, ConnectorHealth, ServiceInfo, MetricInfo, MetricQuery, MetricResult, MetricDefinition, SignalType } from "../types.js";
+export declare class PrometheusConnector implements ObservabilityConnector {
+    readonly type = "prometheus";
+    readonly signalType: SignalType;
+    name: string;
+    private baseUrl;
+    private auth?;
+    private tlsAgent?;
+    private metrics;
+    connect(config: SourceConfig): Promise<void>;
+    getDefaultMetrics(): MetricDefinition[];
+    getMetrics(): MetricDefinition[];
+    setMetrics(metrics: MetricDefinition[]): void;
+    healthCheck(): Promise<ConnectorHealth>;
+    disconnect(): Promise<void>;
+    listServices(): Promise<ServiceInfo[]>;
+    listAvailableMetrics(_service: string): Promise<MetricInfo[]>;
+    queryMetrics(params: MetricQuery): Promise<MetricResult>;
+    private buildQuery;
+    private getUnit;
+    private parseTimeRange;
+    private computeSummary;
+    private computeTrend;
+    private buildAuthHeaders;
+    private fetchOptions;
+    private apiGet;
+}