@thotischner/observability-mcp 1.1.2 → 1.2.0

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/loki.d.ts

@@ -18,7 +18,7 @@ export declare class LokiConnector implements ObservabilityConnector {
     listServices(): Promise<ServiceInfo[]>;
     queryLogs(params: LogQuery): Promise<LogResult>;
     private getLabelValues;
-    private resolveServiceLabel;
+    private resolveServiceSelector;
     private parseLine;
     private extractTopPatterns;
     private parseTimeRange;

package/dist/connectors/loki.js

@@ -61,10 +61,14 @@ export class LokiConnector {
         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,
+            for (const raw of values) {
+                // Docker's loki.source.docker writes container names with a leading '/'
+                // (Docker API Names[0] convention). Strip it for display so the name
+                // matches what the service-name validator and users will pass back in.
+                const display = label === "container" ? raw.replace(/^\//, "") : raw;
+                if (!seen.has(display)) {
+                    seen.set(display, {
+                        name: display,
                         source: this.name,
                         signalType: "logs",
                         labels: { discoveredVia: label },
@@ -77,11 +81,12 @@ export class LokiConnector {
     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);
+        // Resolve label + actual selector value. For the 'container' label the
+        // value stored in Loki may be '/my-app-1' while the caller passes the
+        // sanitized 'my-app-1' — return the prefixed form so the LogQL selector
+        // matches the real stream.
+        const { label: matchedLabel, value: rawValue } = await this.resolveServiceSelector(params.service);
+        const service = this.escapeLogQLValue(rawValue);
         let logql = `{${matchedLabel}="${service}"}`;
         if (params.level) {
             const level = this.escapeLogQLValue(params.level);
@@ -148,13 +153,18 @@ export class LokiConnector {
             return [];
         }
     }
-    async resolveServiceLabel(service) {
+    async resolveServiceSelector(service) {
         for (const label of this.serviceLabels) {
             const values = await this.getLabelValues(label);
             if (values.includes(service))
-                return label;
+                return { label, value: service };
+            // Container label values are Docker-prefixed with '/'. The caller can't
+            // pass that form (validator rejects '/'), so probe the prefixed variant.
+            if (label === "container" && values.includes(`/${service}`)) {
+                return { label, value: `/${service}` };
+            }
         }
-        return this.serviceLabels[0] || "service_name";
+        return { label: this.serviceLabels[0] || "service_name", value: service };
     }
     parseLine(line) {
         try {

package/dist/connectors/prometheus.d.ts

@@ -8,6 +8,8 @@ export declare class PrometheusConnector implements ObservabilityConnector {
     private auth?;
     private tlsAgent?;
     private metrics;
+    private serviceLabels;
+    private labelValuesCache;
     connect(config: SourceConfig): Promise<void>;
     getDefaultMetrics(): MetricDefinition[];
     getMetrics(): MetricDefinition[];
@@ -19,6 +21,8 @@ export declare class PrometheusConnector implements ObservabilityConnector {
     listAvailableMetrics(_service: string): Promise<MetricInfo[]>;
     queryMetrics(params: MetricQuery): Promise<MetricResult>;
     private buildQuery;
+    private resolveServiceLabel;
+    private getLabelValues;
     private getUnit;
     private parseTimeRange;
     private computeSummary;

package/dist/connectors/prometheus.js

@@ -1,13 +1,57 @@
 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: '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" },
+    {
+        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 DEFAULT_SERVICE_LABELS = ["job", "service", "app", "service_name"];
+const LABEL_CACHE_TTL_MS = 60_000;
 export class PrometheusConnector {
     type = "prometheus";
     signalType = "metrics";
@@ -16,15 +60,27 @@ export class PrometheusConnector {
     auth;
     tlsAgent;
     metrics = [];
+    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);
-        // 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. To fully replace the defaults, override every metric explicitly.
+        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 +167,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 +187,48 @@ export class PrometheusConnector {
             unit: this.getUnit(params.metric),
             values,
             summary: this.computeSummary(rawValues),
+            resolvedSeries: promql,
+            resolvedLabel: label,
         };
     }
     // --- Private helpers ---
-    buildQuery(service, metric) {
+    async buildQuery(service, metric) {
         const def = this.metrics.find((m) => m.name === metric);
-        if (def) {
-            return def.query.replace(/\{\{service\}\}/g, service);
+        const 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 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.2",
+  "version": "1.2.0",
   "description": "Unified observability gateway for AI agents — one MCP server for Prometheus, Loki, and any backend",
   "type": "module",
   "license": "MIT",