@thotischner/observability-mcp 1.2.0 → 1.2.1

package/dist/connectors/prometheus.d.ts

@@ -10,6 +10,8 @@ export declare class PrometheusConnector implements ObservabilityConnector {
     private metrics;
     private serviceLabels;
     private labelValuesCache;
+    private metricNamesCache;
+    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 getAllMetricNames;
     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();
+    metricNamesCache = null;
+    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,8 +213,20 @@ export class PrometheusConnector {
     }
     // --- Private helpers ---
     async buildQuery(service, metric) {
-        const def = this.metrics.find((m) => m.name === metric);
-        const template = def?.query || `${metric}{ {{selector}} }`;
+        // Pick the query template. For built-in metrics with no user override,
+        // probe candidate series in the backend and pick the first that exists
+        // (e.g. prom-client process_cpu_seconds_total → falls back to
+        // node_exporter node_cpu_seconds_total). User-overridden metrics use
+        // their query verbatim.
+        let template;
+        if (!this.userOverrides.has(metric) && PROMETHEUS_METRIC_CANDIDATES[metric]) {
+            const candidate = await this.pickMetricCandidate(metric);
+            template = candidate?.query || PROMETHEUS_METRIC_CANDIDATES[metric][0].query;
+        }
+        else {
+            const def = this.metrics.find((m) => m.name === metric);
+            template = def?.query || `${metric}{ {{selector}} }`;
+        }
         const escaped = service.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
         let promql = template;
         let label = "job";
@@ -206,6 +238,34 @@ export class PrometheusConnector {
         promql = promql.replace(/\{\{service\}\}/g, escaped);
         return { promql, label };
     }
+    async pickMetricCandidate(metric) {
+        const candidates = PROMETHEUS_METRIC_CANDIDATES[metric];
+        if (!candidates || candidates.length === 0)
+            return null;
+        if (candidates.length === 1)
+            return candidates[0];
+        const allNames = await this.getAllMetricNames();
+        for (const c of candidates) {
+            if (allNames.has(c.seriesName))
+                return c;
+        }
+        return candidates[0];
+    }
+    async getAllMetricNames() {
+        if (this.metricNamesCache && this.metricNamesCache.expiresAt > Date.now()) {
+            return this.metricNamesCache.values;
+        }
+        try {
+            const data = await this.apiGet("/api/v1/label/__name__/values");
+            const values = new Set(data?.data || []);
+            this.metricNamesCache = { values, expiresAt: Date.now() + LABEL_CACHE_TTL_MS };
+            return values;
+        }
+        catch {
+            this.metricNamesCache = { values: new Set(), expiresAt: Date.now() + LABEL_CACHE_TTL_MS };
+            return new Set();
+        }
+    }
     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.1",
   "description": "Unified observability gateway for AI agents — one MCP server for Prometheus, Loki, and any backend",
   "type": "module",
   "license": "MIT",