simple metric.

Author: larryl3u

Cargo.lock

@@ -0,0 +1,18 @@
+[package]
+name = "movement-health"
+description = "Health utilities for Movement services"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+publish.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+poem = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true

util/health/Cargo.toml

@@ -0,0 +1,15 @@
+use anyhow::Error;
+use poem::listener::TcpListener;
+use poem::{get, handler, IntoResponse, Response, Route, Server};
+
+pub async fn run_service(hostname: String, port: u16) -> Result<(), Error> {
+	let route = Route::new().at("/health", get(health));
+	let url = format!("{}:{}", hostname, port);
+	tracing::info!("Start health check access on :{url} .");
+	Server::new(TcpListener::bind(url)).run(route).await.map_err(Into::into)
+}
+
+#[handler]
+async fn health() -> Response {
+	"{\"OK\": \"healthy\"}".into_response()
+}

util/health/src/lib.rs

@@ -25,8 +25,10 @@ hex = { workspace = true }
 rand = { workspace = true }
 ring = "0.17.7"
 warp = "0.3"
+poem = { workspace = true }
 prometheus = "0.13"
 clap = { workspace = true }
+anyhow = { workspace = true }
 lazy_static = "1.4.0"
 
 [lints]

util/tracing/Cargo.toml

@@ -14,6 +14,8 @@ use tokio::runtime::Runtime;
 use tokio::time;
 use warp::Filter;
 
+pub mod simple_metrics;
+
 // Create a default NodeConfig for telemetry
 static DEFAULT_NODE_CONFIG: Lazy<NodeConfig> = Lazy::new(|| {
 	let mut config = NodeConfig::default();

util/tracing/src/lib.rs

@@ -0,0 +1,44 @@
+use poem::http::StatusCode;
+use poem::{get, handler, listener::TcpListener, IntoResponse, Route, Server};
+use prometheus::{gather, Encoder, TextEncoder};
+use tokio::task::JoinHandle;
+
+/// Start a simple metrics server on the given hostname and port. This is for the usage other than the node.
+pub async fn start_metrics_server(listen_hostname: String, listen_port: u16) -> Result<JoinHandle<()>, anyhow::Error> {
+    let bind_address = format!("{}:{}", listen_hostname, listen_port);
+
+    let metrics_route = Route::new().at("/metrics", get(metrics_handler));
+
+    let server_handle = tokio::spawn(async move {
+        let listener = TcpListener::bind(&bind_address);
+        aptos_logger::info!("Starting Prometheus metrics server on http://{}/metrics", bind_address);
+
+        if let Err(e) = Server::new(listener).run(metrics_route).await {
+            aptos_logger::error!("Metrics server error: {}", e);
+        }
+    });
+
+    Ok(server_handle)
+}
+
+#[handler]
+async fn metrics_handler() -> impl IntoResponse {
+	let metrics = gather();
+	let encoder = TextEncoder::new();
+	let mut buffer = vec![];
+
+	match encoder.encode(&metrics, &mut buffer) {
+		Ok(_) => match String::from_utf8(buffer) {
+			Ok(metrics_text) => poem::Response::builder()
+				.status(StatusCode::OK)
+				.header("content-type", "text/plain")
+				.body(metrics_text),
+			Err(_) => poem::Response::builder()
+				.status(StatusCode::INTERNAL_SERVER_ERROR)
+				.body("Error encoding metrics"),
+		},
+		Err(_) => poem::Response::builder()
+			.status(StatusCode::INTERNAL_SERVER_ERROR)
+			.body("Error gathering metrics"),
+	}
+}