@thotischner/observability-mcp 1.1.0 → 1.1.2

package/dist/connectors/loki.d.ts

@@ -7,6 +7,8 @@ export declare class LokiConnector implements ObservabilityConnector {
     private baseUrl;
     private auth?;
     private tlsAgent?;
+    private serviceLabels;
+    private labelValuesCache;
     connect(config: SourceConfig): Promise<void>;
     getDefaultMetrics(): MetricDefinition[];
     getMetrics(): MetricDefinition[];
@@ -15,6 +17,8 @@ export declare class LokiConnector implements ObservabilityConnector {
     disconnect(): Promise<void>;
     listServices(): Promise<ServiceInfo[]>;
     queryLogs(params: LogQuery): Promise<LogResult>;
+    private getLabelValues;
+    private resolveServiceLabel;
     private parseLine;
     private extractTopPatterns;
     private parseTimeRange;

package/dist/connectors/loki.js

@@ -1,4 +1,6 @@
 import { buildTlsAgent } from "./tls.js";
+const DEFAULT_SERVICE_LABELS = ["service_name", "service", "job", "app", "container"];
+const LABEL_CACHE_TTL_MS = 60_000;
 export class LokiConnector {
     type = "loki";
     signalType = "logs";
@@ -6,11 +8,17 @@ export class LokiConnector {
     baseUrl = "";
     auth;
     tlsAgent;
+    serviceLabels = DEFAULT_SERVICE_LABELS;
+    labelValuesCache = new Map();
     async connect(config) {
         this.name = config.name;
         this.baseUrl = config.url.replace(/\/$/, "");
         this.auth = config.auth;
         this.tlsAgent = buildTlsAgent(config);
+        const envLabels = process.env.LOKI_SERVICE_LABELS;
+        if (envLabels) {
+            this.serviceLabels = envLabels.split(",").map((s) => s.trim()).filter(Boolean);
+        }
     }
     getDefaultMetrics() {
         // Loki is a log backend — no metric definitions by default
@@ -30,13 +38,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) {
@@ -45,23 +54,35 @@ export class LokiConnector {
     }
     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 [];
+        // Probe each candidate label and merge values. Loki streams may identify
+        // services via service_name, service, job, app, or container depending on
+        // the shipper configuration. Walking all candidates ensures historical
+        // streams remain reachable when label conventions change over time.
+        const seen = new Map();
+        for (const label of this.serviceLabels) {
+            const values = await this.getLabelValues(label);
+            for (const name of values) {
+                if (!seen.has(name)) {
+                    seen.set(name, {
+                        name,
+                        source: this.name,
+                        signalType: "logs",
+                        labels: { discoveredVia: label },
+                    });
+                }
+            }
         }
+        return Array.from(seen.values());
     }
     async queryLogs(params) {
         const { start, end } = this.parseTimeRange(params.duration);
         const limit = Math.min(Math.max(params.limit || 100, 1), 1000);
+        // Resolve which label this service identifier lives under. Falls back to
+        // the first configured label when no exact match is found, preserving
+        // legacy behavior for callers passing labels that aren't in the cache yet.
+        const matchedLabel = await this.resolveServiceLabel(params.service);
         const service = this.escapeLogQLValue(params.service);
-        let logql = `{service="${service}"}`;
+        let logql = `{${matchedLabel}="${service}"}`;
         if (params.level) {
             const level = this.escapeLogQLValue(params.level);
             logql += ` | json | level="${level}"`;
@@ -108,6 +129,33 @@ export class LokiConnector {
         };
     }
     // --- Private helpers ---
+    async getLabelValues(label) {
+        const cached = this.labelValuesCache.get(label);
+        if (cached && cached.expiresAt > Date.now()) {
+            return cached.values;
+        }
+        try {
+            const data = await this.apiGet(`/loki/api/v1/label/${encodeURIComponent(label)}/values`);
+            const values = data?.data || [];
+            this.labelValuesCache.set(label, {
+                values,
+                expiresAt: Date.now() + LABEL_CACHE_TTL_MS,
+            });
+            return values;
+        }
+        catch {
+            this.labelValuesCache.set(label, { values: [], expiresAt: Date.now() + LABEL_CACHE_TTL_MS });
+            return [];
+        }
+    }
+    async resolveServiceLabel(service) {
+        for (const label of this.serviceLabels) {
+            const values = await this.getLabelValues(label);
+            if (values.includes(service))
+                return label;
+        }
+        return this.serviceLabels[0] || "service_name";
+    }
     parseLine(line) {
         try {
             return JSON.parse(line);

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.1.0",
+  "version": "1.1.2",
   "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",