Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "exporter"
-version = "0.1.0"
+version = "0.2.3"
 edition = "2021"
 
 [dependencies]

src/endpoints.rs

@@ -7,23 +7,18 @@ use crate::structs::v3::PrometheusMetrics;
 use prometheus::{ Encoder, Gauge, Registry, TextEncoder};
 use std::sync::{ Arc, MutexGuard };
 use crate::AppState;
-use tracing::{ error, debug, info, warn };
+use tracing::{ error, info, warn };
 use crate::metrics::{MetricsProcesser, MetricsValueType};
 
 pub async fn update_metrics(
     State(state): State<Arc<AppState>>,
-    Json(request) : Json<PrometheusMetrics>
+    Json(request) : Json<PrometheusMetrics<'_>>
 ) -> impl IntoResponse {
     info!("post on /update");
-//     let resp = Response::new("body");
-    // debug!("{:?}", request);
-    // debug!("{:?}", MetricsProcesser::get_type_of_value(&request));
     let service = &request.service_name;
     let endpoint = &request.endpoint_name;
 
     for i in request.metrics {
-        // debug!("{:?}", &i);
-        // debug!("{:?}", MetricsProcesser::get_type_of_value(&i));
         let metric_name = format!("{}_{}_{}", service, endpoint, &i.id);
         match MetricsProcesser::get_type_of_value(&i) {
             MetricsValueType::Array | 
@@ -33,7 +28,8 @@ pub async fn update_metrics(
             MetricsValueType::Number => {
                 let gauge = MetricsProcesser::gauge_from_number(
                     &i, 
-                    &metric_name
+                    &metric_name,
+                    &i.desc.clone().unwrap_or_else(|| std::borrow::Cow::Borrowed(&i.id))
                 );
                 if let Some(gauge) = gauge {
                     match state.registry.lock() {
@@ -50,7 +46,6 @@ pub async fn update_metrics(
                         },
                     }
                 }
-                // dbg!(gauge);
             },
             MetricsValueType::ArrayOfStrings => {
                 warn!("String arrays are unsupported, ignoring ...");

src/metrics.rs

@@ -39,10 +39,11 @@ impl MetricsProcesser {
     pub fn gauge_from_number(
         metric: &MetricOutput,
         metric_name: &str,
+        metric_desc: &str
     ) -> Option<Gauge> {        
         let gauge = Gauge::new(
             metric_name,
-            &metric.id
+            metric_desc
         );
 
         match gauge {

src/structs.rs

@@ -1,25 +1,28 @@
 // use std::collections::HashMap;
 use serde::{Serialize, Deserialize};
 use serde_json::Value;
+use std::borrow::Cow;
 // use anyhow::Result;
 // use std::sync::Arc;
 
 pub mod v3 {
     pub use super::*;
     // to prometheus and nmns
-    #[derive(Serialize, Deserialize, Debug)]
+    #[derive(Serialize, Deserialize, Debug, Clone)]
-    pub struct MetricOutput {
+    pub struct MetricOutput<'a> {
         pub id : String,
         #[serde(rename = "type")]
         json_type : String,
         addr : String,
         pub value : Value,
+        #[serde(rename = "description")]
+        pub desc : Option<Cow<'a, String>>,
     }
 
     #[derive(Serialize, Deserialize, Debug)]
-    pub struct PrometheusMetrics {
+    pub struct PrometheusMetrics<'a> {
         pub service_name: String,
         pub endpoint_name: String,
-        pub metrics: Vec<MetricOutput>,
+        pub metrics: Vec<MetricOutput<'a>>,
     }
 }