@thotischner/observability-mcp 1.1.3 → 1.2.1

package/config/sources.yaml

@@ -3,11 +3,21 @@ sources:
     type: prometheus
     url: http://prometheus:9090
     enabled: true
-    # metrics:  # Uncomment to override default Prometheus metrics
-    #   - name: custom_metric
-    #     query: 'my_custom_metric{job="{{service}}"}'
-    #     unit: requests
-    #     description: My custom metric
+    # The demo services emit synthetic CPU/memory gauges that the chaos
+    # endpoints drive directly, so we override the connector defaults
+    # (which target prom-client conventions) with the demo-specific names.
+    # request_rate / error_rate / latency_* keep the prom-client defaults
+    # and apply unchanged because the demo also emits http_requests_total
+    # and http_request_duration_seconds_bucket.
+    metrics:
+      - name: cpu
+        query: 'service_cpu_usage_percent{job="{{service}}"}'
+        unit: percent
+        description: Synthetic CPU gauge driven by /chaos endpoints
+      - name: memory
+        query: 'service_memory_usage_bytes{job="{{service}}"}'
+        unit: bytes
+        description: Synthetic memory gauge driven by /chaos endpoints
 
   - name: loki
     type: loki

package/dist/connectors/prometheus.d.ts

@@ -8,6 +8,10 @@ export declare class PrometheusConnector implements ObservabilityConnector {
     private auth?;
     private tlsAgent?;
     private metrics;
+    private serviceLabels;
+    private labelValuesCache;
+    private metricNamesCache;
+    private userOverrides;
     connect(config: SourceConfig): Promise<void>;
     getDefaultMetrics(): MetricDefinition[];
     getMetrics(): MetricDefinition[];
@@ -19,6 +23,10 @@ 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;
     private parseTimeRange;
     private computeSummary;

package/dist/connectors/prometheus.js

@@ -1,13 +1,73 @@
 import { buildTlsAgent } from "./tls.js";
-const DEFAULT_PROMETHEUS_METRICS = [
-    { name: "cpu", query: 'service_cpu_usage_percent{job="{{service}}"}', unit: "percent", description: "CPU usage percentage" },
-    { name: "memory", query: 'service_memory_usage_bytes{job="{{service}}"}', unit: "bytes", description: "Memory usage in bytes" },
-    { name: "error_rate", query: 'rate(http_requests_total{job="{{service}}",status=~"5.."}[1m])', unit: "req/s", description: "HTTP 5xx error rate" },
-    { name: "request_rate", query: 'rate(http_requests_total{job="{{service}}"}[1m])', unit: "req/s", description: "Total HTTP request rate" },
-    { name: "latency_p99", query: 'histogram_quantile(0.99, rate(http_request_duration_seconds_bucket{job="{{service}}"}[1m]))', unit: "seconds", description: "99th percentile latency" },
-    { name: "latency_p50", query: 'histogram_quantile(0.50, rate(http_request_duration_seconds_bucket{job="{{service}}"}[1m]))', unit: "seconds", description: "50th percentile latency" },
-    { name: "latency_avg", query: 'rate(http_request_duration_seconds_sum{job="{{service}}"}[1m]) / rate(http_request_duration_seconds_count{job="{{service}}"}[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 {
     type = "prometheus";
     signalType = "metrics";
@@ -16,15 +76,31 @@ export class PrometheusConnector {
     auth;
     tlsAgent;
     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(/\/$/, "");
         this.auth = config.auth;
         this.tlsAgent = buildTlsAgent(config);
-        // Use source-level metrics if provided, otherwise connector defaults
-        this.metrics = config.metrics && config.metrics.length > 0
-            ? config.metrics
-            : [...DEFAULT_PROMETHEUS_METRICS];
+        // 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. 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) {
+            if (!DEFAULT_PROMETHEUS_METRICS.some((d) => d.name === name)) {
+                this.metrics.push(m);
+            }
+        }
+        const envLabels = process.env.PROMETHEUS_SERVICE_LABELS;
+        if (envLabels) {
+            this.serviceLabels = envLabels.split(",").map((s) => s.trim()).filter(Boolean);
+        }
     }
     getDefaultMetrics() {
         return DEFAULT_PROMETHEUS_METRICS;
@@ -111,7 +187,7 @@ export class PrometheusConnector {
         return metrics;
     }
     async queryMetrics(params) {
-        const promql = this.buildQuery(params.service, params.metric);
+        const { promql, label } = await this.buildQuery(params.service, params.metric);
         const { start, end, step } = this.parseTimeRange(params.duration, params.step);
         const data = await this.apiGet(`/api/v1/query_range?query=${encodeURIComponent(promql)}&start=${start}&end=${end}&step=${step}`);
         const values = [];
@@ -131,15 +207,88 @@ export class PrometheusConnector {
             unit: this.getUnit(params.metric),
             values,
             summary: this.computeSummary(rawValues),
+            resolvedSeries: promql,
+            resolvedLabel: label,
         };
     }
     // --- Private helpers ---
-    buildQuery(service, metric) {
-        const def = this.metrics.find((m) => m.name === metric);
-        if (def) {
-            return def.query.replace(/\{\{service\}\}/g, service);
+    async buildQuery(service, metric) {
+        // 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";
+        if (template.includes("{{selector}}")) {
+            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) {
+        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);
+            if (values.includes(service))
+                return label;
+        }
+        return this.serviceLabels[0] || "job";
+    }
+    async getLabelValues(label) {
+        const cached = this.labelValuesCache.get(label);
+        if (cached && cached.expiresAt > Date.now()) {
+            return cached.values;
+        }
+        try {
+            const data = await this.apiGet(`/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 [];
         }
-        return `${metric}{job="${service}"}`;
     }
     getUnit(metric) {
         const def = this.metrics.find((m) => m.name === metric);

package/dist/tools/validation.js

@@ -1,5 +1,9 @@
 const DURATION_RE = /^\d+[mhd]$/;
-const SAFE_LABEL_RE = /^[a-zA-Z0-9_\-.:]+$/;
+// Slashes are valid in Prometheus label values and appear in real-world job
+// names (Grafana Cloud Integrations like "integrations/unix", k8s namespaces,
+// Docker image refs). The PromQL/LogQL injection surface is the surrounding
+// quote/backslash, which we escape separately, not these characters.
+const SAFE_LABEL_RE = /^[a-zA-Z0-9_\-.:/]+$/;
 export function validateDuration(duration) {
     if (!DURATION_RE.test(duration)) {
         return `Invalid duration "${duration}". Expected format: <number><unit> where unit is m (minutes), h (hours), or d (days). Examples: 5m, 1h, 24h, 7d`;
@@ -33,7 +37,7 @@ export function sanitizeLabelValue(value) {
 }
 export function validateServiceName(service) {
     if (!sanitizeLabelValue(service)) {
-        return `Invalid service name "${service}". Only alphanumeric characters, hyphens, underscores, dots, and colons are allowed (max 128 chars).`;
+        return `Invalid service name "${service}". Only alphanumeric characters, hyphens, underscores, dots, colons, and slashes are allowed (max 128 chars).`;
     }
     return null;
 }

package/dist/types.d.ts

@@ -121,6 +121,8 @@ export interface MetricResult {
     unit: string;
     values: DataPoint[];
     summary: MetricSummary;
+    resolvedSeries?: string;
+    resolvedLabel?: string;
 }
 export interface LogEntry {
     timestamp: string;

package/package.json

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