[pyth-rng] A few small improvements

pyth-rng/Cargo.toml

@@ -13,6 +13,7 @@ clap        = { version = "4.4.6", features = ["derive", "cargo", "env"] }
 ethabi      = "18.0.0"
 ethers      = "2.0.10"
 hex         = "0.4.3"
+prometheus-client  = { version = "0.21.2" }
 pythnet-sdk = { git = "https://github.com/pyth-network/pyth-crosschain", version = "2.0.0", features = ["strum"] }
 rand        = "0.8.5"
 reqwest     = { version = "0.11.22", features = ["json", "blocking"] }
@@ -23,5 +24,7 @@ serde_yaml = "0.9.25"
 sha3        = "0.10.8"
 tokio       = { version = "1.33.0", features = ["full"] }
 tower-http         = { version = "0.4.0", features = ["cors"] }
+tracing            = { version = "0.1.37", features = ["log"] }
+tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 utoipa             = { version = "3.4.0", features = ["axum_extras"] }
 utoipa-swagger-ui  = { version = "3.1.4", features = ["axum"] }

pyth-rng/src/api.rs

@@ -11,26 +11,44 @@ use {
         },
     },
     ethers::core::types::Address,
+    prometheus_client::{
+        encoding::EncodeLabelSet,
+        metrics::{
+            counter::Counter,
+            family::Family,
+        },
+        registry::Registry,
+    },
     std::{
         collections::HashMap,
         sync::Arc,
     },
+    tokio::sync::RwLock,
 };
 pub use {
     chain_ids::*,
     index::*,
+    live::*,
+    metrics::*,
+    ready::*,
     revelation::*,
 };
 
 mod chain_ids;
 mod index;
+mod live;
+mod metrics;
+mod ready;
 mod revelation;
 
 pub type ChainId = String;
 
 #[derive(Clone)]
 pub struct ApiState {
     pub chains: Arc<HashMap<ChainId, BlockchainState>>,
+
+    /// Prometheus metrics
+    pub metrics: Arc<Metrics>,
 }
 
 /// The state of the randomness service for a single blockchain.
@@ -43,6 +61,38 @@ pub struct BlockchainState {
     pub provider_address: Address,
 }
 
+pub struct Metrics {
+    pub registry:        RwLock<Registry>,
+    // TODO: track useful metrics. this counter is just a placeholder to get things set up.
+    pub request_counter: Family<Label, Counter>,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq, EncodeLabelSet)]
+pub struct Label {
+    value: String,
+}
+
+impl Metrics {
+    pub fn new() -> Self {
+        let mut metrics_registry = Registry::default();
+        let http_requests = Family::<Label, Counter>::default();
+
+        // Register the metric family with the registry.
+        metrics_registry.register(
+            // With the metric name.
+            "http_requests",
+            // And the metric help text.
+            "Number of HTTP requests received",
+            http_requests.clone(),
+        );
+
+        Metrics {
+            registry:        RwLock::new(metrics_registry),
+            request_counter: http_requests,
+        }
+    }
+}
+
 pub enum RestError {
     /// The caller passed a sequence number that isn't within the supported range
     InvalidSequenceNumber,

pyth-rng/src/api/live.rs

@@ -0,0 +1,11 @@
+use axum::{
+    http::StatusCode,
+    response::{
+        IntoResponse,
+        Response,
+    },
+};
+
+pub async fn live() -> Response {
+    (StatusCode::OK, "OK").into_response()
+}

pyth-rng/src/api/metrics.rs

@@ -0,0 +1,20 @@
+//! Exposing prometheus metrics via HTTP in openmetrics format.
+
+use {
+    axum::{
+        extract::State,
+        response::IntoResponse,
+    },
+    prometheus_client::encoding::text::encode,
+};
+
+pub async fn metrics(State(state): State<crate::api::ApiState>) -> impl IntoResponse {
+    let registry = state.metrics.registry.read().await;
+    let mut buffer = String::new();
+
+    // Should not fail if the metrics are valid and there is memory available
+    // to write to the buffer.
+    encode(&mut buffer, &registry).unwrap();
+
+    buffer
+}

pyth-rng/src/api/ready.rs

@@ -0,0 +1,13 @@
+use axum::{
+    http::StatusCode,
+    response::{
+        IntoResponse,
+        Response,
+    },
+};
+
+pub async fn ready() -> Response {
+    // TODO: are there useful checks here? At the moment, everything important (specifically hash
+    // chain computation) occurs synchronously on startup.
+    (StatusCode::OK, "OK").into_response()
+}