refactor: use std::sync::LazyLock instead of lazy_static

Cargo.toml

@@ -19,7 +19,6 @@ opt-level = 3
 
 [workspace.dependencies]
 clap = "4.4.3"
-lazy_static = "1.4.0"
 axum = { version = "0.7.9", default-features = false, features = [
     "tokio",
     "http1",

crates/service/Cargo.toml

@@ -31,7 +31,6 @@ graphql_client.workspace = true
 tracing-subscriber = { workspace = true, features = ["fmt"] }
 clap = { workspace = true, features = ["derive"] }
 build-info.workspace = true
-lazy_static.workspace = true
 prost.workspace = true 
 async-trait.workspace = true
 async-graphql = { version = "7.0.11", default-features = false }

crates/service/src/metrics.rs

@@ -1,39 +1,40 @@
 // Copyright 2023-, Edge & Node, GraphOps, and Semiotic Labs.
 // SPDX-License-Identifier: Apache-2.0
 
-use std::net::SocketAddr;
+use std::{net::SocketAddr, sync::LazyLock};
 
 use axum::{routing::get, serve, Router};
-use lazy_static::lazy_static;
 use prometheus::{
     register_counter_vec, register_histogram_vec, CounterVec, HistogramVec, TextEncoder,
 };
 use reqwest::StatusCode;
 use tokio::net::TcpListener;
 
-lazy_static! {
-    /// Metric registered in global registry for
-    /// indexer query handler
-    ///
-    /// Labels: "deployment", "allocation", "sender"
-    pub static ref HANDLER_HISTOGRAM: HistogramVec = register_histogram_vec!(
+/// Metric registered in global registry for
+/// indexer query handler
+///
+/// Labels: "deployment", "allocation", "sender"
+pub static HANDLER_HISTOGRAM: LazyLock<HistogramVec> = LazyLock::new(|| {
+    register_histogram_vec!(
         "indexer_query_handler_seconds",
         "Histogram for default indexer query handler",
         &["deployment", "allocation", "sender", "status_code"]
-    ).unwrap();
+    )
+    .unwrap()
+});
 
-    /// Metric registered in global registry for
-    /// Failed receipt checks
-    ///
-    /// Labels: "deployment", "allocation", "sender"
-    pub static ref FAILED_RECEIPT: CounterVec = register_counter_vec!(
+/// Metric registered in global registry for
+/// Failed receipt checks
+///
+/// Labels: "deployment", "allocation", "sender"
+pub static FAILED_RECEIPT: LazyLock<CounterVec> = LazyLock::new(|| {
+    register_counter_vec!(
         "indexer_receipt_failed_total",
         "Failed receipt checks",
         &["deployment", "allocation", "sender"]
     )
-    .unwrap();
-
-}
+    .unwrap()
+});
 
 pub fn serve_metrics(host_and_port: SocketAddr) {
     tracing::info!(address = %host_and_port, "Serving prometheus metrics");

crates/service/src/routes/cost.rs

@@ -1,10 +1,9 @@
 // Copyright 2023-, Edge & Node, GraphOps, and Semiotic Labs.
 // SPDX-License-Identifier: Apache-2.0
 
-use std::str::FromStr;
+use std::{str::FromStr, sync::LazyLock};
 
 use async_graphql::{Context, EmptyMutation, EmptySubscription, Object, Schema, SimpleObject};
-use lazy_static::lazy_static;
 use prometheus::{
     register_counter, register_counter_vec, register_histogram, register_histogram_vec, Counter,
     CounterVec, Histogram, HistogramVec,
@@ -16,45 +15,57 @@ use thegraph_core::DeploymentId;
 
 use crate::database::cost_model::{self, CostModel};
 
-lazy_static! {
-    pub static ref COST_MODEL_METRIC: HistogramVec = register_histogram_vec!(
+pub static COST_MODEL_METRIC: LazyLock<HistogramVec> = LazyLock::new(|| {
+    register_histogram_vec!(
         "indexer_cost_model_seconds",
         "Histogram metric for single cost model query",
         &["deployment"]
     )
-    .unwrap();
-    pub static ref COST_MODEL_FAILED: CounterVec = register_counter_vec!(
+    .unwrap()
+});
+pub static COST_MODEL_FAILED: LazyLock<CounterVec> = LazyLock::new(|| {
+    register_counter_vec!(
         "indexer_cost_model_failed_total",
         "Total failed Cost Model query",
         &["deployment"]
     )
-    .unwrap();
-    pub static ref COST_MODEL_INVALID: Counter = register_counter!(
+    .unwrap()
+});
+pub static COST_MODEL_INVALID: LazyLock<Counter> = LazyLock::new(|| {
+    register_counter!(
         "indexer_cost_model_invalid_total",
         "Cost model queries with invalid deployment id",
     )
-    .unwrap();
-    pub static ref COST_MODEL_BATCH_METRIC: Histogram = register_histogram!(
+    .unwrap()
+});
+pub static COST_MODEL_BATCH_METRIC: LazyLock<Histogram> = LazyLock::new(|| {
+    register_histogram!(
         "indexer_cost_model_batch_seconds",
         "Histogram metric for batch cost model query",
     )
-    .unwrap();
-    pub static ref COST_MODEL_BATCH_SIZE: Histogram = register_histogram!(
+    .unwrap()
+});
+pub static COST_MODEL_BATCH_SIZE: LazyLock<Histogram> = LazyLock::new(|| {
+    register_histogram!(
         "indexer_cost_model_batch_size",
         "This shows the size of deployment ids cost model batch queries got",
     )
-    .unwrap();
-    pub static ref COST_MODEL_BATCH_FAILED: Counter = register_counter!(
+    .unwrap()
+});
+pub static COST_MODEL_BATCH_FAILED: LazyLock<Counter> = LazyLock::new(|| {
+    register_counter!(
         "indexer_cost_model_batch_failed_total",
         "Total failed batch cost model queries",
     )
-    .unwrap();
-    pub static ref COST_MODEL_BATCH_INVALID: Counter = register_counter!(
+    .unwrap()
+});
+pub static COST_MODEL_BATCH_INVALID: LazyLock<Counter> = LazyLock::new(|| {
+    register_counter!(
         "indexer_cost_model_batch_invalid_total",
         "Batch cost model queries with invalid deployment ids",
     )
-    .unwrap();
-}
+    .unwrap()
+});
 
 #[derive(Clone, Debug, Serialize, Deserialize, SimpleObject)]
 pub struct GraphQlCostModel {

crates/service/src/routes/status.rs

@@ -1,7 +1,7 @@
 // Copyright 2023-, Edge & Node, GraphOps, and Semiotic Labs.
 // SPDX-License-Identifier: Apache-2.0
 
-use std::collections::HashSet;
+use std::{collections::HashSet, sync::LazyLock};
 
 use async_graphql_axum::GraphQLRequest;
 use axum::{extract::State, response::IntoResponse, Json};
@@ -14,23 +14,24 @@ use thegraph_graphql_http::{
 
 use crate::{error::SubgraphServiceError, service::GraphNodeState};
 
-lazy_static::lazy_static! {
-    static ref SUPPORTED_ROOT_FIELDS: HashSet<&'static str> =
-        vec![
-            "indexingStatuses",
-            "chains",
-            "latestBlock",
-            "earliestBlock",
-            "publicProofsOfIndexing",
-            "entityChangesInBlock",
-            "blockData",
-            "blockHashFromNumber",
-            "cachedEthereumCalls",
-            "subgraphFeatures",
-            "apiVersions",
-            "version"
-        ].into_iter().collect();
-}
+static SUPPORTED_ROOT_FIELDS: LazyLock<HashSet<&'static str>> = LazyLock::new(|| {
+    [
+        "indexingStatuses",
+        "chains",
+        "latestBlock",
+        "earliestBlock",
+        "publicProofsOfIndexing",
+        "entityChangesInBlock",
+        "blockData",
+        "blockHashFromNumber",
+        "cachedEthereumCalls",
+        "subgraphFeatures",
+        "apiVersions",
+        "version",
+    ]
+    .into_iter()
+    .collect()
+});
 
 struct WrappedGraphQLRequest(async_graphql::Request);
 

crates/service/src/service/tap_receipt_header.rs

@@ -1,9 +1,10 @@
 // Copyright 2023-, Edge & Node, GraphOps, and Semiotic Labs.
 // SPDX-License-Identifier: Apache-2.0
 
+use std::sync::LazyLock;
+
 use axum_extra::headers::{self, Header, HeaderName, HeaderValue};
 use base64::prelude::*;
-use lazy_static::lazy_static;
 use prometheus::{register_counter, Counter};
 use prost::Message;
 use tap_aggregator::grpc;
@@ -14,11 +15,10 @@ use crate::tap::TapReceipt;
 #[derive(Debug, PartialEq)]
 pub struct TapHeader(pub TapReceipt);
 
-lazy_static! {
-    static ref TAP_RECEIPT: HeaderName = HeaderName::from_static("tap-receipt");
-    pub static ref TAP_RECEIPT_INVALID: Counter =
-        register_counter!("indexer_tap_invalid_total", "Invalid tap receipt decode",).unwrap();
-}
+static TAP_RECEIPT: LazyLock<HeaderName> = LazyLock::new(|| HeaderName::from_static("tap-receipt"));
+pub static TAP_RECEIPT_INVALID: LazyLock<Counter> = LazyLock::new(|| {
+    register_counter!("indexer_tap_invalid_total", "Invalid tap receipt decode",).unwrap()
+});
 
 impl Header for TapHeader {
     fn name() -> &'static HeaderName {

crates/tap-agent/Cargo.toml

@@ -32,7 +32,6 @@ axum.workspace = true
 tap_core.workspace = true
 tap_graph.workspace = true
 tokio = { workspace = true, features = ["rt-multi-thread"] }
-lazy_static.workspace = true
 thegraph-core.workspace = true
 clap.workspace = true
 tracing-subscriber.workspace = true

crates/tap-agent/src/agent/sender_account.rs

@@ -4,6 +4,7 @@
 use std::{
     collections::{HashMap, HashSet},
     str::FromStr,
+    sync::LazyLock,
     time::Duration,
 };
 
@@ -16,7 +17,6 @@ use indexer_query::{
     unfinalized_transactions, UnfinalizedTransactions,
 };
 use indexer_watcher::watch_pipe;
-use lazy_static::lazy_static;
 use prometheus::{register_gauge_vec, register_int_gauge_vec, GaugeVec, IntGaugeVec};
 use ractor::{Actor, ActorProcessingErr, ActorRef, MessagingErr, SupervisionEvent};
 use reqwest::Url;
@@ -48,52 +48,65 @@ use crate::{
     tracker::{SenderFeeTracker, SimpleFeeTracker},
 };
 
-lazy_static! {
-    static ref SENDER_DENIED: IntGaugeVec =
-        register_int_gauge_vec!("tap_sender_denied", "Sender is denied", &["sender"]).unwrap();
-    static ref ESCROW_BALANCE: GaugeVec = register_gauge_vec!(
+static SENDER_DENIED: LazyLock<IntGaugeVec> = LazyLock::new(|| {
+    register_int_gauge_vec!("tap_sender_denied", "Sender is denied", &["sender"]).unwrap()
+});
+static ESCROW_BALANCE: LazyLock<GaugeVec> = LazyLock::new(|| {
+    register_gauge_vec!(
         "tap_sender_escrow_balance_grt_total",
         "Sender escrow balance",
         &["sender"]
     )
-    .unwrap();
-    static ref UNAGGREGATED_FEES: GaugeVec = register_gauge_vec!(
+    .unwrap()
+});
+static UNAGGREGATED_FEES: LazyLock<GaugeVec> = LazyLock::new(|| {
+    register_gauge_vec!(
         "tap_unaggregated_fees_grt_total",
         "Unggregated Fees value",
         &["sender", "allocation"]
     )
-    .unwrap();
-    static ref SENDER_FEE_TRACKER: GaugeVec = register_gauge_vec!(
+    .unwrap()
+});
+static SENDER_FEE_TRACKER: LazyLock<GaugeVec> = LazyLock::new(|| {
+    register_gauge_vec!(
         "tap_sender_fee_tracker_grt_total",
         "Sender fee tracker metric",
         &["sender"]
     )
-    .unwrap();
-    static ref INVALID_RECEIPT_FEES: GaugeVec = register_gauge_vec!(
+    .unwrap()
+});
+static INVALID_RECEIPT_FEES: LazyLock<GaugeVec> = LazyLock::new(|| {
+    register_gauge_vec!(
         "tap_invalid_receipt_fees_grt_total",
         "Failed receipt fees",
         &["sender", "allocation"]
     )
-    .unwrap();
-    static ref PENDING_RAV: GaugeVec = register_gauge_vec!(
+    .unwrap()
+});
+static PENDING_RAV: LazyLock<GaugeVec> = LazyLock::new(|| {
+    register_gauge_vec!(
         "tap_pending_rav_grt_total",
         "Pending ravs values",
         &["sender", "allocation"]
     )
-    .unwrap();
-    static ref MAX_FEE_PER_SENDER: GaugeVec = register_gauge_vec!(
+    .unwrap()
+});
+static MAX_FEE_PER_SENDER: LazyLock<GaugeVec> = LazyLock::new(|| {
+    register_gauge_vec!(
         "tap_max_fee_per_sender_grt_total",
         "Max fee per sender in the config",
         &["sender"]
     )
-    .unwrap();
-    static ref RAV_REQUEST_TRIGGER_VALUE: GaugeVec = register_gauge_vec!(
+    .unwrap()
+});
+static RAV_REQUEST_TRIGGER_VALUE: LazyLock<GaugeVec> = LazyLock::new(|| {
+    register_gauge_vec!(
         "tap_rav_request_trigger_value",
         "RAV request trigger value divisor",
         &["sender"]
     )
-    .unwrap();
-}
+    .unwrap()
+});
 
 const INITIAL_RAV_REQUEST_CONCURRENT: usize = 1;