chore: remove lazy_static in favor of LazyLock

Author: GuillaumeLagrange

Cargo.lock

@@ -14,7 +14,6 @@ path = "src/main.rs"
 anyhow = { workspace = true }
 clap = { workspace = true, features = ["env", "color"] }
 itertools = { workspace = true }
-lazy_static = "1.4.0"
 log = { workspace = true }
 rand = "0.8.5"
 rayon = "1.10"

Cargo.toml

@@ -1,12 +1,13 @@
+use std::sync::LazyLock;
+
 use anyhow::{Result, anyhow};
-use lazy_static::lazy_static;
 
-lazy_static! {
-    static ref REMOTE_REGEX: regex::Regex = regex::Regex::new(
-        r"(?P<domain>[^/@\.]+\.\w+)[:/](?P<owner>[^/]+)/(?P<repository>[^/]+?)(\.git)?/?$"
+static REMOTE_REGEX: LazyLock<regex::Regex> = LazyLock::new(|| {
+    regex::Regex::new(
+        r"(?P<domain>[^/@\.]+\.\w+)[:/](?P<owner>[^/]+)/(?P<repository>[^/]+?)(\.git)?/?$",
     )
-    .unwrap();
-}
+    .unwrap()
+});
 
 #[derive(Debug)]
 pub struct GitRemote {

src/cli/run/helpers/parse_git_remote.rs

@@ -20,17 +20,16 @@ pub use local_logger::clean_logger;
 pub use project_config::{ProjectConfig, ProjectOptions, Target, TargetOptions, WalltimeOptions};
 pub use runner_mode::RunnerMode;
 
-use lazy_static::lazy_static;
 use semver::Version;
+use std::sync::LazyLock;
 
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 pub const MONGODB_TRACER_VERSION: &str = "cs-mongo-tracer-v0.2.0";
 
 pub const VALGRIND_CODSPEED_VERSION: Version = Version::new(3, 26, 0);
 pub const VALGRIND_CODSPEED_DEB_REVISION_SUFFIX: &str = "0codspeed0";
-lazy_static! {
-    pub static ref VALGRIND_CODSPEED_VERSION_STRING: String =
-        format!("{VALGRIND_CODSPEED_VERSION}.codspeed");
-    pub static ref VALGRIND_CODSPEED_DEB_VERSION: String =
-        format!("{VALGRIND_CODSPEED_VERSION}-{VALGRIND_CODSPEED_DEB_REVISION_SUFFIX}");
-}
+pub static VALGRIND_CODSPEED_VERSION_STRING: LazyLock<String> =
+    LazyLock::new(|| format!("{VALGRIND_CODSPEED_VERSION}.codspeed"));
+pub static VALGRIND_CODSPEED_DEB_VERSION: LazyLock<String> = LazyLock::new(|| {
+    format!("{VALGRIND_CODSPEED_VERSION}-{VALGRIND_CODSPEED_DEB_REVISION_SUFFIX}")
+});

src/lib.rs

@@ -9,10 +9,10 @@ use std::{
 use crate::prelude::*;
 use console::{Style, style};
 use indicatif::{ProgressBar, ProgressStyle};
-use lazy_static::lazy_static;
 use log::Log;
 use simplelog::{CombinedLogger, SharedLogger};
 use std::io::Write;
+use std::sync::LazyLock;
 
 use crate::logger::{GroupEvent, JsonEvent, get_group_event, get_json_event};
 
@@ -24,15 +24,16 @@ pub(crate) const SPINNER_TICKS: &[&str] = &["  ", ". ", "..", " ."];
 /// Interval between spinner animation ticks (milliseconds)
 pub(crate) const TICK_INTERVAL_MS: u64 = 300;
 
-lazy_static! {
-    pub static ref SPINNER: Arc<Mutex<Option<ProgressBar>>> = Arc::new(Mutex::new(None));
-    pub static ref IS_TTY: bool = std::io::IsTerminal::is_terminal(&std::io::stdout());
-    static ref CURRENT_GROUP_NAME: Arc<Mutex<Option<String>>> = Arc::new(Mutex::new(None));
+pub static SPINNER: LazyLock<Arc<Mutex<Option<ProgressBar>>>> =
+    LazyLock::new(|| Arc::new(Mutex::new(None)));
+pub static IS_TTY: LazyLock<bool> =
+    LazyLock::new(|| std::io::IsTerminal::is_terminal(&std::io::stdout()));
+static CURRENT_GROUP_NAME: LazyLock<Arc<Mutex<Option<String>>>> =
+    LazyLock::new(|| Arc::new(Mutex::new(None)));
 
-    /// Log records deferred while the rolling buffer owns the terminal.
-    /// Flushed in `draw_frame` before each redraw.
-    static ref DEFERRED_LOGS: Mutex<Vec<DeferredLog>> = Mutex::new(Vec::new());
-}
+/// Log records deferred while the rolling buffer owns the terminal.
+/// Flushed in `draw_frame` before each redraw.
+static DEFERRED_LOGS: LazyLock<Mutex<Vec<DeferredLog>>> = LazyLock::new(|| Mutex::new(Vec::new()));
 
 /// A snapshot of a log record that can be stored across the rolling-buffer
 /// lifetime (the original `log::Record` borrows data and cannot be kept).

src/local_logger/mod.rs

@@ -7,16 +7,14 @@ use super::{
     CODSPEED_U8_COLOR_CODE, IS_TTY, SPINNER, SPINNER_TICKS, TICK_INTERVAL_MS, format_checkmark,
 };
 use console::{Term, style};
-use lazy_static::lazy_static;
+use std::sync::LazyLock;
 
 const INDENT: &str = "    ";
 
-lazy_static! {
-    /// Global shared rolling buffer, set by `activate_rolling_buffer` and
-    /// consumed by `log_tee` in `run_command_with_log_pipe`.
-    pub(crate) static ref ROLLING_BUFFER: Mutex<Option<RollingBuffer>> =
-        Mutex::new(None);
-}
+/// Global shared rolling buffer, set by `activate_rolling_buffer` and
+/// consumed by `log_tee` in `run_command_with_log_pipe`.
+pub(crate) static ROLLING_BUFFER: LazyLock<Mutex<Option<RollingBuffer>>> =
+    LazyLock::new(|| Mutex::new(None));
 
 /// Stop signal for the tick thread.
 ///

src/local_logger/rolling_buffer/mod.rs

@@ -1,4 +1,5 @@
-use lazy_static::lazy_static;
+use std::sync::LazyLock;
+
 use reqwest::ClientBuilder;
 use reqwest_middleware::{ClientBuilder as ClientWithMiddlewareBuilder, ClientWithMiddleware};
 use reqwest_retry::{RetryTransientMiddleware, policies::ExponentialBackoff};
@@ -7,33 +8,23 @@ const UPLOAD_RETRY_COUNT: u32 = 3;
 const OIDC_RETRY_COUNT: u32 = 10;
 const USER_AGENT: &str = "codspeed-runner";
 
-lazy_static! {
-    pub static ref REQUEST_CLIENT: ClientWithMiddleware = ClientWithMiddlewareBuilder::new(
-        ClientBuilder::new()
-            .user_agent(USER_AGENT)
-            .build()
-            .unwrap()
-    )
-    .with(RetryTransientMiddleware::new_with_policy(
-        ExponentialBackoff::builder().build_with_max_retries(UPLOAD_RETRY_COUNT)
-    ))
-    .build();
-
-    // Client without retry middleware for streaming uploads (can't be cloned)
-    pub static ref STREAMING_CLIENT: reqwest::Client = ClientBuilder::new()
-        .user_agent(USER_AGENT)
+pub static REQUEST_CLIENT: LazyLock<ClientWithMiddleware> = LazyLock::new(|| {
+    ClientWithMiddlewareBuilder::new(ClientBuilder::new().user_agent(USER_AGENT).build().unwrap())
+        .with(RetryTransientMiddleware::new_with_policy(
+            ExponentialBackoff::builder().build_with_max_retries(UPLOAD_RETRY_COUNT),
+        ))
         .build()
-        .unwrap();
+});
 
-    // Client with retry middleware for OIDC token requests
-    pub static ref OIDC_CLIENT: ClientWithMiddleware = ClientWithMiddlewareBuilder::new(
-        ClientBuilder::new()
-            .user_agent(USER_AGENT)
-            .build()
-            .unwrap()
-    )
-    .with(RetryTransientMiddleware::new_with_policy(
-        ExponentialBackoff::builder().build_with_max_retries(OIDC_RETRY_COUNT)
-    ))
-    .build();
-}
+/// Client without retry middleware for streaming uploads (can't be cloned)
+pub static STREAMING_CLIENT: LazyLock<reqwest::Client> =
+    LazyLock::new(|| ClientBuilder::new().user_agent(USER_AGENT).build().unwrap());
+
+/// Client with retry middleware for OIDC token requests
+pub static OIDC_CLIENT: LazyLock<ClientWithMiddleware> = LazyLock::new(|| {
+    ClientWithMiddlewareBuilder::new(ClientBuilder::new().user_agent(USER_AGENT).build().unwrap())
+        .with(RetryTransientMiddleware::new_with_policy(
+            ExponentialBackoff::builder().build_with_max_retries(OIDC_RETRY_COUNT),
+        ))
+        .build()
+});

src/request_client.rs

@@ -1,6 +1,7 @@
+use std::sync::LazyLock;
+
 use async_trait::async_trait;
 use git2::Repository;
-use lazy_static::lazy_static;
 use regex::Regex;
 use serde::Deserialize;
 use serde_json::Value;
@@ -63,9 +64,8 @@ struct OIDCResponse {
     value: Option<String>,
 }
 
-lazy_static! {
-    static ref PR_REF_REGEX: Regex = Regex::new(r"^refs/pull/(?P<pr_number>\d+)/merge$").unwrap();
-}
+static PR_REF_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^refs/pull/(?P<pr_number>\d+)/merge$").unwrap());
 
 impl TryFrom<&OrchestratorConfig> for GitHubActionsProvider {
     type Error = Error;

src/run_environment/github_actions/provider.rs

@@ -1,5 +1,6 @@
+use std::sync::LazyLock;
+
 use console::style;
-use lazy_static::lazy_static;
 use log::{Level, LevelFilter, Log};
 use regex::Regex;
 use simplelog::SharedLogger;
@@ -15,10 +16,8 @@ use crate::{
     run_environment::logger::should_provider_logger_handle_record,
 };
 
-lazy_static! {
-    static ref GITLAB_SECTION_ID_SANITIZE_REGEX: Regex =
-        Regex::new(r"[^\d\w\-_]").expect("Failed to compile GitLab SectionId regex");
-}
+static GITLAB_SECTION_ID_SANITIZE_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"[^\d\w\-_]").expect("Failed to compile GitLab SectionId regex"));
 
 /// Unicode Escape character
 ///

src/run_environment/gitlab_ci/logger.rs

@@ -1,12 +1,12 @@
-use lazy_static::lazy_static;
 use std::collections::HashSet;
+use std::sync::LazyLock;
 
 use crate::prelude::*;
 
 use super::SystemInfo;
 
-lazy_static! {
-    static ref SUPPORTED_SYSTEMS: HashSet<(&'static str, &'static str, &'static str)> = {
+static SUPPORTED_SYSTEMS: LazyLock<HashSet<(&'static str, &'static str, &'static str)>> =
+    LazyLock::new(|| {
         HashSet::from([
             ("ubuntu", "22.04", "x86_64"),
             ("ubuntu", "24.04", "x86_64"),
@@ -15,8 +15,7 @@ lazy_static! {
             ("debian", "12", "x86_64"),
             ("debian", "12", "aarch64"),
         ])
-    };
-}
+    });
 
 /// Checks if the provided system info is supported
 ///