Show the resolved default settings path in --help; add Prometheus/OpenMetrics polling

--settings-path's help text now names the actual resolved default path
(computed once via LazyLock) instead of only describing where to look for
one. Also adds an optional --metrics-url flag that polls a Prometheus/
OpenMetrics-compatible endpoint on an interval, pushing samples straight
into a metric's bucket (bypassing log-line regex matching) so they're
queryable via PromQL/dashboards alongside log-derived metrics.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XFUNZwCvz3kcod3352ZR2o

src/ingest.rs

@@ -1,7 +1,8 @@
+use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 
-use crate::engine::{EngineMessage, IngestedLine};
+use crate::engine::{EngineMessage, IngestedLine, MetricSample};
 use crate::timestamp::Timestamp;
 use tokio::fs::File;
 use tokio::io::{AsyncBufReadExt, BufReader};
@@ -9,6 +10,8 @@ use tokio::sync::mpsc;
 
 const POLL_INTERVAL: Duration = Duration::from_millis(200);
 
+const METRICS_POLL_INTERVAL: Duration = Duration::from_secs(15);
+
 /// Reads stdin line by line, sequences and timestamps each line, and forwards it
 /// to the engine task.
 pub async fn run(engine: mpsc::Sender<EngineMessage>) {
@@ -118,6 +121,120 @@ pub async fn run_file(engine: mpsc::Sender<EngineMessage>, path: PathBuf) {
     }
 }
 
+/// Polls `url` on a fixed interval for a Prometheus/OpenMetrics-format response, pushing every parsed
+/// sample straight into the engine. Errors (unreachable endpoint, non-2xx response) are only logged —
+/// polling keeps retrying on the next tick rather than exiting.
+pub async fn run_metrics_poll(engine: mpsc::Sender<EngineMessage>, url: String) {
+    let client = reqwest::Client::new();
+    loop {
+        match client.get(&url).send().await {
+            Ok(response) => match response.error_for_status() {
+                Ok(response) => match response.text().await {
+                    Ok(body) => {
+                        let now = Timestamp::now();
+                        for sample in parse_openmetrics(&body, now) {
+                            if engine.send(EngineMessage::IngestMetricSample(sample)).await.is_err() {
+                                return;
+                            }
+                        }
+                    }
+                    Err(err) => eprintln!("warning: failed to read metrics response from {url}: {err}"),
+                },
+                Err(err) => eprintln!("warning: metrics endpoint {url} returned an error: {err}"),
+            },
+            Err(err) => eprintln!("warning: failed to poll metrics endpoint {url}: {err}"),
+        }
+        tokio::time::sleep(METRICS_POLL_INTERVAL).await;
+    }
+}
+
+/// Parses the Prometheus text exposition / OpenMetrics format: one sample per non-comment,
+/// non-empty line, as `metric_name{label="value",...} value [timestamp_ms]` (labels and the
+/// timestamp are both optional). A line that doesn't parse is skipped rather than aborting the
+/// whole scrape.
+fn parse_openmetrics(body: &str, now: Timestamp) -> Vec<MetricSample> {
+    body.lines().filter_map(|line| parse_openmetrics_line(line, now)).collect()
+}
+
+fn parse_openmetrics_line(line: &str, now: Timestamp) -> Option<MetricSample> {
+    let line = line.trim();
+    if line.is_empty() || line.starts_with('#') {
+        return None;
+    }
+
+    let (name_and_labels, rest) = line.split_once(char::is_whitespace)?;
+    let mut fields = rest.split_whitespace();
+    let value: f64 = fields.next()?.parse().ok()?;
+    let timestamp = fields
+        .next()
+        .and_then(|raw| raw.parse::<f64>().ok())
+        .map(|ms| Timestamp::from_millis(ms as i64))
+        .unwrap_or(now);
+
+    let (metric_name, labels) = match name_and_labels.find('{') {
+        Some(open) => {
+            let close = name_and_labels.rfind('}')?;
+            (name_and_labels[..open].to_string(), parse_openmetrics_labels(&name_and_labels[open + 1..close]))
+        }
+        None => (name_and_labels.to_string(), BTreeMap::new()),
+    };
+    if metric_name.is_empty() {
+        return None;
+    }
+
+    Some(MetricSample { metric_name, labels, value, timestamp })
+}
+
+/// Splits on commas without handling an escaped comma inside a quoted label value — fine for the
+/// common case this targets, not a full OpenMetrics-grammar parser.
+fn parse_openmetrics_labels(raw: &str) -> BTreeMap<String, String> {
+    raw.split(',')
+        .filter_map(|pair| pair.split_once('='))
+        .map(|(name, value)| (name.trim().to_string(), value.trim().trim_matches('"').to_string()))
+        .collect()
+}
+
+#[cfg(test)]
+mod openmetrics_tests {
+    use super::*;
+
+    #[test]
+    fn parses_bare_metric_without_labels_or_timestamp() {
+        let now = Timestamp::from_millis(1000);
+        let samples = parse_openmetrics("requests_total 42\n", now);
+        assert_eq!(samples.len(), 1);
+        assert_eq!(samples[0].metric_name, "requests_total");
+        assert_eq!(samples[0].value, 42.0);
+        assert!(samples[0].labels.is_empty());
+        assert_eq!(samples[0].timestamp, now);
+    }
+
+    #[test]
+    fn parses_labels_and_explicit_timestamp() {
+        let now = Timestamp::from_millis(1000);
+        let samples = parse_openmetrics(
+            r#"http_requests_total{method="GET",path="/a"} 7 5000"#,
+            now,
+        );
+        assert_eq!(samples.len(), 1);
+        let sample = &samples[0];
+        assert_eq!(sample.metric_name, "http_requests_total");
+        assert_eq!(sample.value, 7.0);
+        assert_eq!(sample.labels.get("method").map(String::as_str), Some("GET"));
+        assert_eq!(sample.labels.get("path").map(String::as_str), Some("/a"));
+        assert_eq!(sample.timestamp, Timestamp::from_millis(5000));
+    }
+
+    #[test]
+    fn skips_comments_blank_lines_and_malformed_lines() {
+        let now = Timestamp::from_millis(0);
+        let body = "# HELP requests_total docs\n# TYPE requests_total counter\n\nnot a valid line\nrequests_total 1\n";
+        let samples = parse_openmetrics(body, now);
+        assert_eq!(samples.len(), 1);
+        assert_eq!(samples[0].metric_name, "requests_total");
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;