diff --git a/.env.example b/.env.example index d82e45f..d6acc3c 100644 --- a/.env.example +++ b/.env.example @@ -1,3 +1,8 @@ # port binding for prometheus-exporter # default value = 9100 PROMETHEUS_EXPORTER_PORT = 9100 + +# setting up max level of logging +# default - INFO +# values : WARN, ERROR, INFO, DEBUG, TRACE +PROMETHEUS_EXPORTER_LOG_LEVEL = "TRACE" \ No newline at end of file diff --git a/src/endpoints.rs b/src/endpoints.rs index d3d1525..fe2104f 100644 --- a/src/endpoints.rs +++ b/src/endpoints.rs @@ -3,11 +3,12 @@ use axum::{ response::IntoResponse, http }; +use tracing_subscriber::field::debug; use crate::structs::v3::PrometheusMetrics; use prometheus::{ Encoder, Gauge, Registry, TextEncoder}; use std::sync::{ Arc, MutexGuard }; use crate::AppState; -use tracing::{ debug, error, info, warn }; +use tracing::{ debug, error, info, warn, trace }; use crate::metrics::{MetricsProcesser, MetricsValueType}; /// An `Update` endpoint @@ -18,14 +19,14 @@ use crate::metrics::{MetricsProcesser, MetricsValueType}; /// # Usage /// /// ``` bash -/// curl -X POST -d '"id" : ...' 'http::/localhost:9100/update' +/// curl -X POST -d '...' 'http::/localhost:9100/update' /// ``` /// pub async fn update_metrics( State(state): State>, Json(request) : Json> ) -> impl IntoResponse { - info!("post on /update"); + trace!("post on /update"); let service = &request.service_name; let endpoint = &request.endpoint_name; @@ -35,9 +36,11 @@ pub async fn update_metrics( match MetricsProcesser::get_type_of_value(&i) { MetricsValueType::Array | MetricsValueType::TaggedArray => { - + trace!("processing an array of metrics"); + // ... }, MetricsValueType::Number => { + trace!("processing a number type of metric"); let gauge = MetricsProcesser::gauge_from_number( &i, &metric_name, @@ -60,9 +63,11 @@ pub async fn update_metrics( } }, MetricsValueType::ArrayOfStrings => { + trace!("processing an array of strings"); warn!("String arrays are unsupported, ignoring ..."); }, _ => { + trace!("processing unrecognized type of metric"); warn!("Unrecognized metric type was supplied, ignoring ..."); } } @@ -83,13 +88,18 @@ pub async fn update_metrics( /// ``` /// pub async fn metrics_handler(State(state): State>) -> String { + trace!("get on /metrics"); let registry = state.registry.lock(); + debug!("registry mutex lock is {}", registry.is_ok()); return match registry { Ok(registry) => { let encoder = TextEncoder::new(); let mut buffer = Vec::new(); let metric_families = registry.gather(); + + debug!("vec of metric families - {:?}", &metric_families); + encoder.encode(&metric_families, &mut buffer).unwrap(); String::from_utf8(buffer).unwrap() }, @@ -109,6 +119,7 @@ pub fn update_or_insert_metric<'a>( registry: MutexGuard<'a, Registry>, metric_name: &str ) -> anyhow::Result<()> { + trace!("fn update_or_insert_metric is running"); use prometheus::Error; // let mut counter = 0; match registry.register(Box::new(metric.clone())) { @@ -119,7 +130,7 @@ pub fn update_or_insert_metric<'a>( // update or throw away match er { Error::AlreadyReg => { - + trace!("processing already regged metric"); match registry.unregister(Box::new(metric.clone())) { Ok(_) => { if let Err(er) = registry.register(Box::new(metric)) { diff --git a/src/main.rs b/src/main.rs index e691d1f..a424e45 100644 --- a/src/main.rs +++ b/src/main.rs @@ -11,7 +11,7 @@ use axum::{ routing::{get, post}, Router}; use prometheus::Registry; -use std::sync::{Arc, Mutex}; +use std::{str::FromStr, sync::{Arc, Mutex}}; use endpoints::*; use tokio::net::TcpListener; use tracing::info; @@ -27,8 +27,17 @@ struct AppState { #[tokio::main] async fn main() -> anyhow::Result<()> { + let log_level = std::env::var("PROMETHEUS_EXPORTER_LOG_LEVEL") + .unwrap_or_else(|_| "INFO".to_owned()); + tracing_subscriber::fmt() - .with_max_level(tracing::Level::DEBUG) + .with_max_level(tracing::Level::from_str(&log_level).unwrap_or_else(|_| tracing::Level::INFO)) + .with_writer(std::io::stdout) + .with_span_events(tracing_subscriber::fmt::format::FmtSpan::NEW) + .with_line_number(false) + .with_target(false) + .with_file(false) + .compact() .init(); info!("Loading env vars from .env if exists ..."); @@ -49,10 +58,12 @@ async fn main() -> anyhow::Result<()> { .route("/update", post(update_metrics)) .with_state(state.clone()); - let bind_address = format!("0.0.0.0:{}", std::env::var("PROMETHEUS_EXPORTER_PORT").unwrap_or_else(|_| "9100".to_owned())); - let listener = TcpListener::bind(bind_address).await.unwrap(); + let port = std::env::var("PROMETHEUS_EXPORTER_PORT") + .unwrap_or_else(|_| "9100".to_owned()); + let bind_address = format!("0.0.0.0:{}", &port); + let listener = TcpListener::bind(bind_address).await?; - info!("Serving on ...:9100"); + info!("Serving on ...:{}", &port); axum::serve(listener, app).await?; Ok(()) } \ No newline at end of file diff --git a/src/metrics.rs b/src/metrics.rs index 87aa996..bc53f63 100644 --- a/src/metrics.rs +++ b/src/metrics.rs @@ -1,9 +1,11 @@ use crate::structs::v3::MetricOutput; +use serde::de; use serde_json::{Map, Value}; use prometheus::Gauge; use tracing::error; use prometheus::Opts; use prometheus::GaugeVec; +use tracing::{debug, trace}; #[derive(Debug)] pub enum MetricsValueType { @@ -20,18 +22,24 @@ pub struct MetricsProcesser; impl MetricsProcesser { pub fn get_type_of_value(metrics: &MetricOutput) -> MetricsValueType { + trace!("defining metric type"); if Self::is_number(metrics) { + debug!("processing Number"); return MetricsValueType::Number; } else if Self::is_array(metrics) { if Self::is_tagged_array(metrics) { + debug!("processing TaggedArray"); return MetricsValueType::TaggedArray; } if Self::is_array_of_string_values(metrics) { + debug!("processing ArrayOfStrings"); return MetricsValueType::ArrayOfStrings; } + debug!("processing Array"); return MetricsValueType::Array; } + debug!("processing undefined type"); MetricsValueType::None } @@ -41,6 +49,7 @@ impl MetricsProcesser { metric_name: &str, metric_desc: &str ) -> Option { + trace!("fn gauge_from_number is running"); let gauge = Gauge::new( metric_name, metric_desc @@ -64,6 +73,7 @@ impl MetricsProcesser { }, }; gauge.set(val); + debug!("processed metric: {:?}", &gauge); return Some(gauge); }, Err(er) => error!("Cannot create Gauge metric {} due to {}", &metric_name, er), diff --git a/src/structs.rs b/src/structs.rs index b480f3a..a15eee7 100644 --- a/src/structs.rs +++ b/src/structs.rs @@ -17,6 +17,7 @@ pub mod v3 { pub value : Value, #[serde(rename = "description")] pub desc : Option>, + pub status: Option } #[derive(Serialize, Deserialize, Debug)]