@thotischner/observability-mcp 1.0.0 → 1.1.1

package/dist/config/loader.d.ts

@@ -1,5 +1,6 @@
 import type { Config, GeneralSettings, HealthThresholds } from "../types.js";
 export declare const DEFAULT_SETTINGS: GeneralSettings;
 export declare const DEFAULT_HEALTH_THRESHOLDS: HealthThresholds;
+export declare function substituteEnv(raw: string): string;
 export declare function loadConfig(): Config;
 export declare function saveConfig(config: Config): void;

package/dist/config/loader.js

@@ -23,10 +23,21 @@ export const DEFAULT_HEALTH_THRESHOLDS = {
     logErrors: { good: 1, warn: 5, crit: 20 },
     statusBoundaries: { healthy: 80, degraded: 50 },
 };
+export function substituteEnv(raw) {
+    return raw.replace(/\$\{([A-Z_][A-Z0-9_]*)(?::-([^}]*))?\}/gi, (_match, name, fallback) => {
+        const val = process.env[name];
+        if (val !== undefined)
+            return val;
+        if (fallback !== undefined)
+            return fallback;
+        console.warn(`[config] env var \${${name}} is undefined`);
+        return "";
+    });
+}
 export function loadConfig() {
     try {
         const raw = readFileSync(CONFIG_PATH, "utf-8");
-        const parsed = yaml.load(raw);
+        const parsed = yaml.load(substituteEnv(raw));
         return {
             sources: parsed?.sources || [],
             settings: { ...DEFAULT_SETTINGS, ...parsed?.settings },

package/dist/config/loader.test.js

@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 import { writeFileSync, mkdirSync, rmSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { substituteEnv } from "./loader.js";
 // 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());
@@ -129,6 +130,67 @@ sources:
             assert.equal(config.healthThresholds.statusBoundaries.healthy, 80);
         });
     });
+    describe("substituteEnv", () => {
+        it("replaces ${VAR} with process.env value", () => {
+            process.env.TEST_FOO = "bar";
+            assert.equal(substituteEnv('value: "${TEST_FOO}"'), 'value: "bar"');
+            delete process.env.TEST_FOO;
+        });
+        it("uses default with ${VAR:-default} when unset", () => {
+            delete process.env.TEST_UNSET;
+            assert.equal(substituteEnv('value: "${TEST_UNSET:-fallback}"'), 'value: "fallback"');
+        });
+        it("prefers env value over default", () => {
+            process.env.TEST_SET = "real";
+            assert.equal(substituteEnv('value: "${TEST_SET:-fallback}"'), 'value: "real"');
+            delete process.env.TEST_SET;
+        });
+        it("returns empty string for undefined var without default", () => {
+            delete process.env.TEST_MISSING;
+            const origWarn = console.warn;
+            console.warn = () => { };
+            try {
+                assert.equal(substituteEnv('value: "${TEST_MISSING}"'), 'value: ""');
+            }
+            finally {
+                console.warn = origWarn;
+            }
+        });
+        it("leaves yaml without placeholders unchanged", () => {
+            const yaml = "sources:\n  - name: prom\n    url: http://localhost:9090\n";
+            assert.equal(substituteEnv(yaml), yaml);
+        });
+        it("handles multiple substitutions in one string", () => {
+            process.env.A = "1";
+            process.env.B = "2";
+            assert.equal(substituteEnv("${A}-${B}-${C:-3}"), "1-2-3");
+            delete process.env.A;
+            delete process.env.B;
+        });
+        it("substitutes inside loaded YAML config", async () => {
+            process.env.GRAFANA_USER = "12345";
+            process.env.GRAFANA_TOKEN = "secret-token";
+            const configPath = join(TMP_DIR, "envsubst.yaml");
+            writeFileSync(configPath, `
+sources:
+  - name: grafana
+    type: prometheus
+    url: https://grafana.example.com
+    enabled: true
+    auth:
+      type: basic
+      username: "\${GRAFANA_USER}"
+      password: "\${GRAFANA_TOKEN}"
+`);
+            process.env.CONFIG_PATH = configPath;
+            const mod = await import("./loader.js?" + Date.now());
+            const config = mod.loadConfig();
+            assert.equal(config.sources[0].auth?.username, "12345");
+            assert.equal(config.sources[0].auth?.password, "secret-token");
+            delete process.env.GRAFANA_USER;
+            delete process.env.GRAFANA_TOKEN;
+        });
+    });
     describe("config merging", () => {
         it("merges partial settings with defaults", async () => {
             const configPath = join(TMP_DIR, "partial.yaml");

package/dist/connectors/loki.js

@@ -30,13 +30,14 @@ export class LokiConnector {
     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";
+            // Use the labels query API instead of /ready: managed Loki (Grafana
+            // Cloud, etc.) does not expose the operational health endpoint.
+            // /loki/api/v1/labels returns 200 with auth on any reachable Loki.
+            const res = await fetch(`${this.baseUrl}/loki/api/v1/labels`, this.fetchOptions());
             return {
-                status: isReady ? "up" : "down",
+                status: res.ok ? "up" : "down",
                 latencyMs: Date.now() - start,
-                message: isReady ? "Loki is ready" : `HTTP ${res.status}: ${text}`,
+                message: res.ok ? "Loki is ready" : `HTTP ${res.status}`,
             };
         }
         catch (err) {

package/dist/connectors/prometheus.d.ts

@@ -15,6 +15,7 @@ export declare class PrometheusConnector implements ObservabilityConnector {
     healthCheck(): Promise<ConnectorHealth>;
     disconnect(): Promise<void>;
     listServices(): Promise<ServiceInfo[]>;
+    private listServicesFromJobLabel;
     listAvailableMetrics(_service: string): Promise<MetricInfo[]>;
     queryMetrics(params: MetricQuery): Promise<MetricResult>;
     private buildQuery;

package/dist/connectors/prometheus.js

@@ -38,7 +38,11 @@ export class PrometheusConnector {
     async healthCheck() {
         const start = Date.now();
         try {
-            const res = await fetch(`${this.baseUrl}/-/ready`, this.fetchOptions());
+            // Use the query API instead of /-/ready: works on both OSS Prometheus
+            // and managed offerings (Grafana Cloud / Mimir, AWS Managed Prometheus,
+            // Chronosphere) which do not expose the operational health endpoint.
+            // 'up' is a synthetic metric guaranteed to exist on any Prometheus.
+            const res = await fetch(`${this.baseUrl}/api/v1/query?query=up`, this.fetchOptions());
             return {
                 status: res.ok ? "up" : "down",
                 latencyMs: Date.now() - start,
@@ -51,21 +55,47 @@ export class PrometheusConnector {
     }
     async disconnect() { }
     async listServices() {
-        const data = await this.apiGet("/api/v1/targets");
-        const targets = data?.data?.activeTargets || [];
-        const services = new Map();
-        for (const t of targets) {
-            const name = t.labels?.service || t.labels?.job || t.discoveredLabels?.__address__ || "unknown";
-            if (!services.has(name)) {
-                services.set(name, {
-                    name,
-                    source: this.name,
-                    signalType: "metrics",
-                    labels: t.labels,
-                });
+        // Prefer /api/v1/targets — gives full label detail incl. service/job/address.
+        // Managed Prometheus (Mimir, AMP, Chronosphere) returns 404 on this path
+        // because targets are an operational concept of the OSS scraper. Fall back
+        // to /api/v1/label/job/values, which is the canonical query-time source
+        // for service names and is supported everywhere.
+        try {
+            const data = await this.apiGet("/api/v1/targets");
+            const targets = data?.data?.activeTargets || [];
+            if (targets.length === 0) {
+                return await this.listServicesFromJobLabel();
+            }
+            const services = new Map();
+            for (const t of targets) {
+                const name = t.labels?.service || t.labels?.job || t.discoveredLabels?.__address__ || "unknown";
+                if (!services.has(name)) {
+                    services.set(name, {
+                        name,
+                        source: this.name,
+                        signalType: "metrics",
+                        labels: t.labels,
+                    });
+                }
+            }
+            return Array.from(services.values());
+        }
+        catch (err) {
+            const msg = String(err);
+            if (msg.includes("404")) {
+                return await this.listServicesFromJobLabel();
             }
+            throw err;
         }
-        return Array.from(services.values());
+    }
+    async listServicesFromJobLabel() {
+        const data = await this.apiGet("/api/v1/label/job/values");
+        const jobs = data?.data || [];
+        return jobs.map((name) => ({
+            name,
+            source: this.name,
+            signalType: "metrics",
+        }));
     }
     async listAvailableMetrics(_service) {
         const data = await this.apiGet("/api/v1/metadata");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thotischner/observability-mcp",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Unified observability gateway for AI agents — one MCP server for Prometheus, Loki, and any backend",
   "type": "module",
   "license": "MIT",
@@ -9,11 +9,21 @@
     "type": "git",
     "url": "https://github.com/ThoTischner/observability-mcp"
   },
-  "keywords": ["mcp", "observability", "prometheus", "loki", "model-context-protocol", "anomaly-detection"],
+  "keywords": [
+    "mcp",
+    "observability",
+    "prometheus",
+    "loki",
+    "model-context-protocol",
+    "anomaly-detection"
+  ],
   "bin": {
     "observability-mcp": "./dist/index.js"
   },
-  "files": ["dist", "config"],
+  "files": [
+    "dist",
+    "config"
+  ],
   "scripts": {
     "dev": "tsx watch src/index.ts",
     "build": "tsc && cp -r src/ui dist/ui",