Added additional labels for targets

Author: Thomas Luijken

README.md

@@ -101,6 +101,9 @@ organisationX:
   polling_interval_seconds: 20
   targets:
     - url: http://www.example.com
+      labels:
+        environment: production
+        region: west-eu
 ```
 
 Each top-level key (e.g., `demo`, `organisationX`) represents a distinct probe group. The configuration allows you to define:
@@ -110,6 +113,7 @@ Each top-level key (e.g., `demo`, `organisationX`) represents a distinct probe g
 * `targets`: List of endpoints to monitor.
   * `url`: The target URL.
   * `accepted_status_codes` (optional): A list of HTTP status codes considered successful.
+  * `labels` (optional): A list of additional labels to send with the timeseries metrics.
 
 ---
 

oxybox/example-config.yml

@@ -5,10 +5,14 @@ demo:
     - url: https://www.google.com
     - url: https://www.github.com
       accepted_status_codes: [200, 301]
-    - url: https://grafana.com/
+    - url: https://expired.badssl.com
+      accepted_status_codes: [200, 495, 526]
 
 organisationX:
-  organisation_id: another-org
+  organisation_id: 1
   polling_interval_seconds: 20
   targets:
     - url: http://www.example.com
+      labels:
+        environment: production
+        hello: world

oxybox/src/config/probe_config.rs

@@ -1,4 +1,13 @@
-use serde::Deserialize;
+use serde::{Deserialize, Deserializer};
+use std::collections::HashMap;
+
+fn deserialize_labels<'de, D>(deserializer: D) -> Result<Option<Vec<(String, String)>>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let map = Option::<HashMap<String, String>>::deserialize(deserializer)?;
+    Ok(map.map(|m| m.into_iter().collect()))
+}
 
 /// An organisation configuration for the OxyBox service.
 /// Contains the organisation ID, the polling interval in seconds, and a list of target configurations.
@@ -26,6 +35,12 @@ pub struct TargetConfig {
     /// Defaults to 200 if not specified.
     #[serde(default = "default_status_codes")]
     pub accepted_status_codes: Vec<u16>,
+
+    /// Additional labels to be included in the Mimir metrics for this target.
+    /// This is an optional field that can contain a list of key-value pairs representing the labels.
+    /// For example, you could include labels like `env: production` or `region: us-east-1` to provide more context about the target service in the metrics.
+    #[serde(default, deserialize_with = "deserialize_labels")]
+    pub labels: Option<Vec<(String, String)>>,
 }
 
 fn default_status_codes() -> Vec<u16> {

oxybox/src/http_probe/probe.rs

@@ -261,17 +261,16 @@ pub async fn run_probe_loop(
             let target = target.clone();
             let tenant_name = tenant_name.clone();
             let org_id = org_config.organisation_id.clone();
+            let labels = target.labels.clone();
             let mimir_endpoint = mimir_endpoint.clone();
             let client = client.clone();
 
             handles.push(tokio::spawn(async move {
                 // ✅ Permit is held until the task returns
                 let _permit = semaphore.acquire_owned().await.expect("Semaphore closed");
 
-                // ✅ Jitter per task
                 sleep(jitter(250)).await;
 
-                // ✅ Timeout wraps the whole probe work
                 let result = tokio::time::timeout(probe_timeout, async {
                     handle_target_probe(
                         tenant_name,
@@ -282,6 +281,7 @@ pub async fn run_probe_loop(
                         &resolver,
                         &mimir_endpoint,
                         max_org_width,
+                        labels,
                     )
                     .await
                 })
@@ -332,6 +332,7 @@ fn to_fixed_width(input: &str, width: usize) -> String {
 ///     * `resolver` - The DNS resolver for resolving hostnames.
 ///     * `mimir_target` - The Mimir endpoint to send metrics to.
 ///     * `max_width` - The maximum width for tenant name formatting in logs.
+///     * `labels` - Optional additional labels to include in the metrics.
 async fn handle_target_probe(
     tenant: String,
     org_id: &str,
@@ -341,6 +342,7 @@ async fn handle_target_probe(
     resolver: &TokioAsyncResolver,
     mimir_target: &str,
     max_width: usize,
+    labels: Option<Vec<(String, String)>>,
 ) {
     let url = &target.url;
     let result = probe_url(client.clone(), tls_connector, resolver, url).await;
@@ -351,6 +353,12 @@ async fn handle_target_probe(
         .as_secs_f64();
     let padded_tenant = to_fixed_width(&tenant, max_width);
 
+    let labels = labels.as_ref().map(|l| {                                                                                                                                                                                                               
+        l.iter()                                                                                                                                                                                                                                         
+            .map(|(k, v)| (k.as_str(), v.as_str()))
+            .collect::<Vec<(&str, &str)>>()                                                                                                                                                                                                              
+    });      
+
     match result {
         Ok(probe) => {
             let accepted = probe
@@ -377,7 +385,12 @@ async fn handle_target_probe(
                 );
             }
 
-            let metrics = create_probe_metrics(&probe, accepted);
+            let metrics = create_probe_metrics(
+                &probe, 
+                accepted, 
+                labels
+            );
+
             if let Err(e) = send_to_mimir(mimir_target, Some(org_id), metrics).await {
                 log::error!("[{padded_tenant}] Failed to send metrics for {url}: {e}");
             }
@@ -397,7 +410,7 @@ async fn handle_target_probe(
                 transfer_time: None,
                 total_probe_time: 0.0,
             };
-            let metrics = create_probe_metrics(&probe, false);
+            let metrics = create_probe_metrics(&probe, false, labels);
             if let Err(e) = send_to_mimir(mimir_target, Some(org_id), metrics).await {
                 log::error!("[{padded_tenant}] Failed to send error metrics for {url}: {e}");
             }

oxybox/src/mimir/mod.rs

@@ -58,6 +58,7 @@ fn create_time_series(
 pub fn create_probe_metrics(
     probe_result: &ProbeResult,
     probe_success: bool,
+    labels: Option<Vec<(&str, &str)>>,
 ) -> Vec<prompb::TimeSeries> {
     let mut metrics = Vec::new();
     let probe_successful = match probe_success {
@@ -69,7 +70,7 @@ pub fn create_probe_metrics(
         PROBE_SUCCESS_METRIC,
         &probe_result.url,
         probe_successful,
-        None,
+        labels,
     ));
 
     let phases = [