@thotischner/observability-mcp 1.2.0 → 1.2.2

package/dist/connectors/prometheus.d.ts

@@ -10,6 +10,8 @@ export declare class PrometheusConnector implements ObservabilityConnector {
     private metrics;
     private serviceLabels;
     private labelValuesCache;
+    private candidateCache;
+    private userOverrides;
     connect(config: SourceConfig): Promise<void>;
     getDefaultMetrics(): MetricDefinition[];
     getMetrics(): MetricDefinition[];
@@ -21,6 +23,8 @@ export declare class PrometheusConnector implements ObservabilityConnector {
     listAvailableMetrics(_service: string): Promise<MetricInfo[]>;
     queryMetrics(params: MetricQuery): Promise<MetricResult>;
     private buildQuery;
+    private pickMetricCandidate;
+    private seriesExistsForService;
     private resolveServiceLabel;
     private getLabelValues;
     private getUnit;

package/dist/connectors/prometheus.js

@@ -1,55 +1,71 @@
 import { buildTlsAgent } from "./tls.js";
-// Defaults target prom-client conventions, the de-facto standard for
-// Node.js/Express instrumentation and what most apps emit out of the box.
-// {{selector}} is replaced at query time with the discovered label/value
-// pair (e.g. job="my-svc"); the connector probes job → service → app →
-// service_name to find which label carries the requested service name.
-// {{service}} (literal value) is still supported for back-compat with
-// user-provided overrides.
-const DEFAULT_PROMETHEUS_METRICS = [
-    {
-        name: "cpu",
-        query: 'rate(process_cpu_seconds_total{ {{selector}} }[1m]) * 100',
-        unit: "percent",
-        description: "CPU usage % (rate of process_cpu_seconds_total — prom-client default)",
-    },
-    {
-        name: "memory",
-        query: 'process_resident_memory_bytes{ {{selector}} }',
-        unit: "bytes",
-        description: "Resident memory in bytes (prom-client default)",
-    },
-    {
-        name: "request_rate",
-        query: 'sum(rate(http_requests_total{ {{selector}} }[1m]))',
-        unit: "req/s",
-        description: "HTTP request rate",
-    },
-    {
-        name: "error_rate",
-        query: 'sum(rate(http_requests_total{ {{selector}}, status=~"5.." }[1m]))',
-        unit: "req/s",
-        description: "HTTP 5xx error rate",
-    },
-    {
-        name: "latency_p99",
-        query: 'histogram_quantile(0.99, sum(rate(http_request_duration_seconds_bucket{ {{selector}} }[1m])) by (le))',
-        unit: "seconds",
-        description: "99th percentile latency",
-    },
-    {
-        name: "latency_p50",
-        query: 'histogram_quantile(0.50, sum(rate(http_request_duration_seconds_bucket{ {{selector}} }[1m])) by (le))',
-        unit: "seconds",
-        description: "50th percentile latency",
-    },
-    {
-        name: "latency_avg",
-        query: 'sum(rate(http_request_duration_seconds_sum{ {{selector}} }[1m])) / sum(rate(http_request_duration_seconds_count{ {{selector}} }[1m]))',
-        unit: "seconds",
-        description: "Average request latency",
-    },
-];
+const PROMETHEUS_METRIC_CANDIDATES = {
+    cpu: [
+        {
+            seriesName: "process_cpu_seconds_total",
+            query: 'rate(process_cpu_seconds_total{ {{selector}} }[1m]) * 100',
+        },
+        {
+            seriesName: "node_cpu_seconds_total",
+            query: '100 - avg(rate(node_cpu_seconds_total{ {{selector}}, mode="idle" }[1m])) * 100',
+        },
+    ],
+    memory: [
+        {
+            seriesName: "process_resident_memory_bytes",
+            query: 'process_resident_memory_bytes{ {{selector}} }',
+        },
+        {
+            seriesName: "node_memory_MemTotal_bytes",
+            query: '(node_memory_MemTotal_bytes{ {{selector}} } - node_memory_MemAvailable_bytes{ {{selector}} })',
+        },
+    ],
+    request_rate: [
+        {
+            seriesName: "http_requests_total",
+            query: 'sum(rate(http_requests_total{ {{selector}} }[1m]))',
+        },
+    ],
+    error_rate: [
+        {
+            seriesName: "http_requests_total",
+            query: 'sum(rate(http_requests_total{ {{selector}}, status=~"5.." }[1m]))',
+        },
+    ],
+    latency_p99: [
+        {
+            seriesName: "http_request_duration_seconds_bucket",
+            query: 'histogram_quantile(0.99, sum(rate(http_request_duration_seconds_bucket{ {{selector}} }[1m])) by (le))',
+        },
+    ],
+    latency_p50: [
+        {
+            seriesName: "http_request_duration_seconds_bucket",
+            query: 'histogram_quantile(0.50, sum(rate(http_request_duration_seconds_bucket{ {{selector}} }[1m])) by (le))',
+        },
+    ],
+    latency_avg: [
+        {
+            seriesName: "http_request_duration_seconds_sum",
+            query: 'sum(rate(http_request_duration_seconds_sum{ {{selector}} }[1m])) / sum(rate(http_request_duration_seconds_count{ {{selector}} }[1m]))',
+        },
+    ],
+};
+const DEFAULT_METRIC_META = {
+    cpu: { unit: "percent", description: "CPU usage % (auto: prom-client process_cpu_seconds_total or node_exporter node_cpu_seconds_total)" },
+    memory: { unit: "bytes", description: "Resident memory bytes (auto: prom-client process_resident_memory_bytes or node_memory used)" },
+    request_rate: { unit: "req/s", description: "HTTP request rate (http_requests_total)" },
+    error_rate: { unit: "req/s", description: "HTTP 5xx error rate (http_requests_total filtered by status)" },
+    latency_p99: { unit: "seconds", description: "99th percentile latency (http_request_duration_seconds_bucket)" },
+    latency_p50: { unit: "seconds", description: "50th percentile latency (http_request_duration_seconds_bucket)" },
+    latency_avg: { unit: "seconds", description: "Average request latency (sum/count ratio)" },
+};
+const DEFAULT_PROMETHEUS_METRICS = Object.keys(PROMETHEUS_METRIC_CANDIDATES).map((name) => ({
+    name,
+    query: PROMETHEUS_METRIC_CANDIDATES[name][0].query,
+    unit: DEFAULT_METRIC_META[name].unit,
+    description: DEFAULT_METRIC_META[name].description,
+}));
 const DEFAULT_SERVICE_LABELS = ["job", "service", "app", "service_name"];
 const LABEL_CACHE_TTL_MS = 60_000;
 export class PrometheusConnector {
@@ -62,6 +78,8 @@ export class PrometheusConnector {
     metrics = [];
     serviceLabels = DEFAULT_SERVICE_LABELS;
     labelValuesCache = new Map();
+    candidateCache = new Map();
+    userOverrides = new Set();
     async connect(config) {
         this.name = config.name;
         this.baseUrl = config.url.replace(/\/$/, "");
@@ -69,7 +87,9 @@ export class PrometheusConnector {
         this.tlsAgent = buildTlsAgent(config);
         // Source-level overrides merge with defaults by name, so users can pin
         // a single metric (e.g. cpu) to a custom query without re-listing the
-        // rest. To fully replace the defaults, override every metric explicitly.
+        // rest. Overridden metrics skip candidate probing — the user-supplied
+        // query is used verbatim.
+        this.userOverrides = new Set((config.metrics || []).map((m) => m.name));
         const overrides = new Map((config.metrics || []).map((m) => [m.name, m]));
         this.metrics = DEFAULT_PROMETHEUS_METRICS.map((d) => overrides.get(d.name) || d);
         for (const [name, m] of overrides) {
@@ -193,19 +213,75 @@ export class PrometheusConnector {
     }
     // --- Private helpers ---
     async buildQuery(service, metric) {
-        const def = this.metrics.find((m) => m.name === metric);
-        const template = def?.query || `${metric}{ {{selector}} }`;
+        // Resolve the service-filter label first. Candidate probing uses this
+        // label to scope existence checks per-service rather than per-source.
         const escaped = service.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-        let promql = template;
         let label = "job";
-        if (template.includes("{{selector}}")) {
+        let template;
+        if (!this.userOverrides.has(metric) && PROMETHEUS_METRIC_CANDIDATES[metric]) {
             label = await this.resolveServiceLabel(service);
+            const candidate = await this.pickMetricCandidate(metric, label, escaped);
+            template = candidate?.query || PROMETHEUS_METRIC_CANDIDATES[metric][0].query;
+        }
+        else {
+            const def = this.metrics.find((m) => m.name === metric);
+            template = def?.query || `${metric}{ {{selector}} }`;
+        }
+        let promql = template;
+        if (template.includes("{{selector}}")) {
+            // Resolve label here for non-candidate paths that haven't done it yet.
+            if (label === "job" && !PROMETHEUS_METRIC_CANDIDATES[metric]) {
+                label = await this.resolveServiceLabel(service);
+            }
             const selector = `${label}="${escaped}"`;
             promql = promql.replace(/\{\{selector\}\}/g, selector);
         }
         promql = promql.replace(/\{\{service\}\}/g, escaped);
         return { promql, label };
     }
+    async pickMetricCandidate(metric, label, escapedService) {
+        const candidates = PROMETHEUS_METRIC_CANDIDATES[metric];
+        if (!candidates || candidates.length === 0)
+            return null;
+        if (candidates.length === 1)
+            return candidates[0];
+        // Per-service cache: a source can have BOTH process_* and node_* series
+        // present (e.g. an apps stack alongside node_exporter), so probing has
+        // to check whether THIS service has the series, not whether the source
+        // has it anywhere.
+        const cacheKey = `${metric}|${label}|${escapedService}`;
+        const cached = this.candidateCache.get(cacheKey);
+        if (cached && cached.expiresAt > Date.now())
+            return cached.candidate;
+        for (const c of candidates) {
+            if (await this.seriesExistsForService(c.seriesName, label, escapedService)) {
+                this.candidateCache.set(cacheKey, {
+                    candidate: c,
+                    expiresAt: Date.now() + LABEL_CACHE_TTL_MS,
+                });
+                return c;
+            }
+        }
+        // Nothing found — return first candidate as best-effort. Cache the
+        // negative outcome so we don't probe again for 60s.
+        const fallback = candidates[0];
+        this.candidateCache.set(cacheKey, {
+            candidate: fallback,
+            expiresAt: Date.now() + LABEL_CACHE_TTL_MS,
+        });
+        return fallback;
+    }
+    async seriesExistsForService(seriesName, label, escapedService) {
+        try {
+            const matchExpr = `${seriesName}{${label}="${escapedService}"}`;
+            const url = `/api/v1/series?match[]=${encodeURIComponent(matchExpr)}`;
+            const data = await this.apiGet(url);
+            return Array.isArray(data?.data) && data.data.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
     async resolveServiceLabel(service) {
         for (const label of this.serviceLabels) {
             const values = await this.getLabelValues(label);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thotischner/observability-mcp",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Unified observability gateway for AI agents — one MCP server for Prometheus, Loki, and any backend",
   "type": "module",
   "license": "MIT",