103 lines
3.1 KiB
Rust
103 lines
3.1 KiB
Rust
use axum::{
|
|
extract::{Json, State},
|
|
response::IntoResponse,
|
|
http
|
|
};
|
|
use integr_structs::api::v3::PrometheusMetrics;
|
|
use prometheus::{Encoder, Registry, TextEncoder, Gauge};
|
|
use std::sync::{Arc, MutexGuard};
|
|
use crate::AppState;
|
|
// use log::{warn, info, error};
|
|
use tracing::{info, error, warn};
|
|
use crate::metrics::{MetricsProcesser, MetricsValueType};
|
|
|
|
pub async fn update_metrics(
|
|
State(state): State<Arc<AppState>>,
|
|
Json(request) : Json<PrometheusMetrics>
|
|
) -> impl IntoResponse {
|
|
info!("post on /update");
|
|
// let resp = Response::new("body");
|
|
// println!("{:?}", 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 |
|
|
MetricsValueType::TaggedArray => {
|
|
|
|
},
|
|
MetricsValueType::Number => {
|
|
let gauge = MetricsProcesser::gauge_from_number(
|
|
&i,
|
|
&metric_name
|
|
);
|
|
if let Some(gauge) = gauge {
|
|
match state.registry.lock() {
|
|
Err(er) => {
|
|
error!("Cannot lock Metric Registry due to {} ", er)
|
|
},
|
|
Ok(registry) => {
|
|
update_or_insert_metric(
|
|
gauge,
|
|
registry,
|
|
&metric_name
|
|
);
|
|
},
|
|
}
|
|
}
|
|
// dbg!(gauge);
|
|
},
|
|
MetricsValueType::ArrayOfStrings => {
|
|
warn!("String arrays are unsupported, ignoring ...");
|
|
},
|
|
_ => {
|
|
warn!("Unrecognized metric type was supplied, ignoring ...");
|
|
}
|
|
}
|
|
}
|
|
|
|
(http::StatusCode::ACCEPTED, "Ok")
|
|
}
|
|
|
|
pub async fn metrics_handler(State(state): State<Arc<AppState>>) -> String {
|
|
let registry = state.registry.lock();
|
|
|
|
return match registry {
|
|
Ok(registry) => {
|
|
let encoder = TextEncoder::new();
|
|
let mut buffer = Vec::new();
|
|
let metric_families = registry.gather();
|
|
encoder.encode(&metric_families, &mut buffer).unwrap();
|
|
String::from_utf8(buffer).unwrap()
|
|
},
|
|
Err(er) => {
|
|
format!("Cannot lock Metric Registry due to {} ", er)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn update_or_insert_metric<'a>(
|
|
metric: Gauge,
|
|
registry: MutexGuard<'a, Registry>,
|
|
metric_name: &str
|
|
) {
|
|
// let mut counter = 0;
|
|
match registry.register(Box::new(metric)) {
|
|
Ok(_) => {
|
|
info!("Metric `{}` was added!", metric_name);
|
|
},
|
|
Err(_er) => {
|
|
// update
|
|
},
|
|
}
|
|
// registry.gather()
|
|
// .iter()
|
|
// .filter(|fam| fam.get_name().)
|
|
|
|
}
|