chore(deps): Drop usage of once_cell::LazyLock (#21511)

Author: bruceg

Cargo.lock

@@ -12,7 +12,7 @@ default-run = "vector"
 autobenches = false # our benchmarks are not runnable on their own either way
 # Minimum supported rust version
 # See docs/DEVELOPING.md for policy
-rust-version = "1.79"
+rust-version = "1.80"
 
 [[bin]]
 name = "vector"
@@ -329,7 +329,6 @@ async-nats = { version = "0.33.0", default-features = false, optional = true }
 nkeys = { version = "0.4.4", default-features = false, optional = true }
 nom = { version = "7.1.3", default-features = false, optional = true }
 notify = { version = "6.1.1", default-features = false, features = ["macos_fsevent"] }
-once_cell = { version = "1.20", default-features = false }
 openssl = { version = "0.10.66", default-features = false, features = ["vendored"] }
 openssl-probe = { version = "0.1.5", default-features = false }
 ordered-float = { version = "4.3.0", default-features = false }

Cargo.toml

@@ -280,13 +280,10 @@ ordering.
 When there is a need or desire to share global state, there are a few options depending on the
 required constraints.
 
-If you're working with data that is _lazily initialized_ but _never changes after initialization_,
-we prefer **[`once_cell`](https://docs.rs/once_cell)**. It is slightly faster than
-[`lazy_static`](https://docs.rs/lazy-static), and additionally provides a richer API than both
-`lazy_static` and the standard library variants, such as `std::sync::Once`. Additionally, there is
-[active work happening](https://github.com/rust-lang/rust/issues/74465) to migrate the types in
-`once_cell` into `std::sync` directly, which will be easier to switch to if we're already using
-`once_cell`.
+If you're working with data that _never changes after initialization_,
+we prefer `std::sync::OnceLock` over **[`once_cell`](https://docs.rs/once_cell)** or
+[`lazy_static`](https://docs.rs/lazy-static). It is slightly faster and provides a richer API than
+`lazy_static`, and has equivalent features to the `once_cell` version.
 
 If you're working with data that _changes over time_, but has a very high read-to-write ratio, such
 as _many readers_, but _one writer_ and infrequent writes, we prefer

STYLE.md

@@ -9,4 +9,6 @@ disallowed-methods = [
 disallowed-types = [
   { path = "once_cell::sync::OnceCell", reason = "Use `std::sync::OnceLock` instead." },
   { path = "once_cell::unsync::OnceCell", reason = "Use `std::cell::OnceCell` instead." },
+  { path = "once_cell::sync::Lazy", reason = "Use `std::sync::LazyLock` instead." },
+  { path = "once_cell::unsync::Lazy", reason = "Use `std::sync::LazyCell` instead." },
 ]

clippy.toml

@@ -19,7 +19,6 @@ dyn-clone = { version = "1", default-features = false }
 influxdb-line-protocol = { version = "2", default-features = false }
 lookup = { package = "vector-lookup", path = "../vector-lookup", default-features = false, features = ["test"] }
 memchr = { version = "2", default-features = false }
-once_cell = { version = "1.20", default-features = false }
 ordered-float = { version = "4.3.0", default-features = false }
 prost.workspace = true
 prost-reflect.workspace = true

lib/codecs/Cargo.toml

@@ -1,6 +1,7 @@
 //! Contains common definitions for GELF codec support
 
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
+
 use regex::Regex;
 use vrl::owned_value_path;
 use vrl::path::OwnedTargetPath;
@@ -54,21 +55,23 @@ pub(crate) struct GelfTargetPaths {
 }
 
 /// Lazily initialized singleton.
-pub(crate) static GELF_TARGET_PATHS: Lazy<GelfTargetPaths> = Lazy::new(|| GelfTargetPaths {
-    version: OwnedTargetPath::event(owned_value_path!(gelf_fields::VERSION)),
-    host: OwnedTargetPath::event(owned_value_path!(gelf_fields::HOST)),
-    full_message: OwnedTargetPath::event(owned_value_path!(gelf_fields::FULL_MESSAGE)),
-    level: OwnedTargetPath::event(owned_value_path!(gelf_fields::LEVEL)),
-    facility: OwnedTargetPath::event(owned_value_path!(gelf_fields::FACILITY)),
-    line: OwnedTargetPath::event(owned_value_path!(gelf_fields::LINE)),
-    file: OwnedTargetPath::event(owned_value_path!(gelf_fields::FILE)),
-    short_message: OwnedTargetPath::event(owned_value_path!(gelf_fields::SHORT_MESSAGE)),
-});
+pub(crate) static GELF_TARGET_PATHS: LazyLock<GelfTargetPaths> =
+    LazyLock::new(|| GelfTargetPaths {
+        version: OwnedTargetPath::event(owned_value_path!(gelf_fields::VERSION)),
+        host: OwnedTargetPath::event(owned_value_path!(gelf_fields::HOST)),
+        full_message: OwnedTargetPath::event(owned_value_path!(gelf_fields::FULL_MESSAGE)),
+        level: OwnedTargetPath::event(owned_value_path!(gelf_fields::LEVEL)),
+        facility: OwnedTargetPath::event(owned_value_path!(gelf_fields::FACILITY)),
+        line: OwnedTargetPath::event(owned_value_path!(gelf_fields::LINE)),
+        file: OwnedTargetPath::event(owned_value_path!(gelf_fields::FILE)),
+        short_message: OwnedTargetPath::event(owned_value_path!(gelf_fields::SHORT_MESSAGE)),
+    });
 
 /// Regex for matching valid field names in the encoder. According to the original spec by graylog,
 /// must contain only word chars, periods and dashes. Additional field names must also be prefixed
 /// with an `_` , however that is intentionally omitted from this regex to be checked separately
 /// to create a specific error message.
 /// As Graylog itself will produce GELF with any existing field names on the Graylog GELF Output,
 /// vector is more lenient, too, at least allowing the additional `@` character.
-pub static VALID_FIELD_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^[\w\.\-@]*$").unwrap());
+pub static VALID_FIELD_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^[\w\.\-@]*$").unwrap());

lib/codecs/src/gelf.rs

@@ -43,7 +43,6 @@ crossbeam-queue = "0.3.11"
 hdrhistogram = "7.5.4"
 metrics-tracing-context.workspace = true
 metrics-util = { workspace = true, features = ["debugging"] }
-once_cell = "1.20"
 proptest = "1.5"
 quickcheck = "1.0"
 rand = "0.8.5"

lib/vector-buffers/Cargo.toml

@@ -1,6 +1,5 @@
-use std::{future::Future, path::Path, str::FromStr};
+use std::{future::Future, path::Path, str::FromStr, sync::LazyLock};
 
-use once_cell::sync::Lazy;
 use temp_dir::TempDir;
 use tracing_fluent_assertions::{AssertionRegistry, AssertionsLayer};
 use tracing_subscriber::{filter::LevelFilter, layer::SubscriberExt, Layer, Registry};
@@ -72,7 +71,7 @@ pub fn install_tracing_helpers() -> AssertionRegistry {
     //
     // TODO: At some point, we might be able to write a simple derive macro that does this for us, and
     // configures the other necessary bits, but for now.... by hand will get the job done.
-    static ASSERTION_REGISTRY: Lazy<AssertionRegistry> = Lazy::new(|| {
+    static ASSERTION_REGISTRY: LazyLock<AssertionRegistry> = LazyLock::new(|| {
         let assertion_registry = AssertionRegistry::default();
         let assertions_layer = AssertionsLayer::new(&assertion_registry);
 

lib/vector-buffers/src/test/helpers.rs

@@ -7,7 +7,6 @@ license = "MPL-2.0"
 [dependencies]
 convert_case = { version = "0.6", default-features = false }
 darling = { version = "0.20", default-features = false, features = ["suggestions"] }
-once_cell = { version = "1", default-features = false, features = ["std"] }
 proc-macro2 = { version = "1.0", default-features = false }
 serde.workspace = true
 serde_json.workspace = true

lib/vector-config-common/Cargo.toml

@@ -1,14 +1,14 @@
 use std::collections::{HashMap, HashSet};
+use std::sync::LazyLock;
 
 use convert_case::{Boundary, Case, Converter};
-use once_cell::sync::Lazy;
 
 /// Well-known replacements.
 ///
 /// Replacements are instances of strings with unique capitalization that cannot be achieved
 /// programmatically, as well as the potential insertion of additional characters, such as the
 /// replacement of "pubsub" with "Pub/Sub".
-static WELL_KNOWN_REPLACEMENTS: Lazy<HashMap<String, &'static str>> = Lazy::new(|| {
+static WELL_KNOWN_REPLACEMENTS: LazyLock<HashMap<String, &'static str>> = LazyLock::new(|| {
     let pairs = vec![
         ("eventstoredb", "EventStoreDB"),
         ("mongodb", "MongoDB"),
@@ -43,7 +43,7 @@ static WELL_KNOWN_REPLACEMENTS: Lazy<HashMap<String, &'static str>> = Lazy::new(
 /// Acronyms are distinct from replacements because they should be entirely capitalized (i.e. "aws"
 /// or "aWs" or "Aws" should always be replaced with "AWS") whereas replacements may insert
 /// additional characters or capitalize specific characters within the original string.
-static WELL_KNOWN_ACRONYMS: Lazy<HashSet<String>> = Lazy::new(|| {
+static WELL_KNOWN_ACRONYMS: LazyLock<HashSet<String>> = LazyLock::new(|| {
     let acronyms = &[
         "api", "amqp", "aws", "ec2", "ecs", "gcp", "hec", "http", "https", "nats", "nginx", "s3",
         "sqs", "tls", "ssl", "otel", "gelf", "csv", "json", "rfc3339", "lz4", "us", "eu", "bsd",

lib/vector-config-common/src/human_friendly.rs

@@ -35,7 +35,6 @@ metrics-tracing-context.workspace = true
 metrics-util.workspace = true
 mlua = { version = "0.9.9", default-features = false, features = ["lua54", "send", "vendored"], optional = true }
 no-proxy = { version  = "0.3.5", default-features = false, features = ["serialize"] }
-once_cell = { version = "1.20", default-features = false }
 ordered-float = { version = "4.3.0", default-features = false }
 openssl = { version = "0.10.66", default-features = false, features = ["vendored"] }
 parking_lot = { version = "0.12.3", default-features = false }

lib/vector-core/Cargo.toml

@@ -1,12 +1,11 @@
-use std::sync::OnceLock;
+use std::sync::{LazyLock, OnceLock};
 
 use lookup::lookup_v2::OptionalTargetPath;
 use lookup::{OwnedTargetPath, OwnedValuePath};
-use once_cell::sync::Lazy;
 use vector_config::configurable_component;
 
 static LOG_SCHEMA: OnceLock<LogSchema> = OnceLock::new();
-static LOG_SCHEMA_DEFAULT: Lazy<LogSchema> = Lazy::new(LogSchema::default);
+static LOG_SCHEMA_DEFAULT: LazyLock<LogSchema> = LazyLock::new(LogSchema::default);
 
 const MESSAGE: &str = "message";
 const TIMESTAMP: &str = "timestamp";

lib/vector-core/src/config/log_schema.rs

@@ -1,11 +1,10 @@
-use std::sync::OnceLock;
+use std::sync::{LazyLock, OnceLock};
 
-use once_cell::sync::Lazy;
 use vector_common::request_metadata::GroupedCountByteSize;
 use vector_config::configurable_component;
 
 static TELEMETRY: OnceLock<Telemetry> = OnceLock::new();
-static TELEMETRY_DEFAULT: Lazy<Telemetry> = Lazy::new(Telemetry::default);
+static TELEMETRY_DEFAULT: LazyLock<Telemetry> = LazyLock::new(Telemetry::default);
 
 /// Loads the telemetry options from configurations and sets the global options.
 /// Once this is done, configurations can be correctly loaded using configured

lib/vector-core/src/config/telemetry.rs

@@ -1,19 +1,19 @@
-use crate::event::util::log::all_fields_skip_array_elements;
-use bytes::Bytes;
-use chrono::Utc;
 use std::{
     collections::HashMap,
     convert::{TryFrom, TryInto},
     fmt::Debug,
     iter::FromIterator,
     mem::size_of,
     num::NonZeroUsize,
-    sync::Arc,
+    sync::{Arc, LazyLock},
 };
 
+use crate::event::util::log::all_fields_skip_array_elements;
+use bytes::Bytes;
+use chrono::Utc;
+
 use crossbeam_utils::atomic::AtomicCell;
 use lookup::{lookup_v2::TargetPath, metadata_path, path, PathPrefix};
-use once_cell::sync::Lazy;
 use serde::{Deserialize, Serialize, Serializer};
 use vector_common::{
     byte_size_of::ByteSizeOf,
@@ -36,7 +36,7 @@ use crate::config::{log_schema, telemetry};
 use crate::event::util::log::{all_fields, all_metadata_fields};
 use crate::event::MaybeAsLogMut;
 
-static VECTOR_SOURCE_TYPE_PATH: Lazy<Option<OwnedTargetPath>> = Lazy::new(|| {
+static VECTOR_SOURCE_TYPE_PATH: LazyLock<Option<OwnedTargetPath>> = LazyLock::new(|| {
     Some(OwnedTargetPath::metadata(owned_value_path!(
         "vector",
         "source_type"
@@ -761,7 +761,7 @@ struct TracingTargetPaths {
 }
 
 /// Lazily initialized singleton.
-static TRACING_TARGET_PATHS: Lazy<TracingTargetPaths> = Lazy::new(|| TracingTargetPaths {
+static TRACING_TARGET_PATHS: LazyLock<TracingTargetPaths> = LazyLock::new(|| TracingTargetPaths {
     timestamp: OwnedTargetPath::event(owned_value_path!("timestamp")),
     kind: OwnedTargetPath::event(owned_value_path!("metadata", "kind")),
     level: OwnedTargetPath::event(owned_value_path!("metadata", "level")),

lib/vector-core/src/event/log_event.rs

@@ -1,12 +1,13 @@
-use once_cell::sync::Lazy;
+use std::{collections::btree_map, fmt::Write as _, iter, slice, sync::LazyLock};
+
 use regex::Regex;
 use serde::{Serialize, Serializer};
-use std::{collections::btree_map, fmt::Write as _, iter, slice};
 use vrl::path::PathPrefix;
 
 use crate::event::{KeyString, ObjectMap, Value};
 
-static IS_VALID_PATH_SEGMENT: Lazy<Regex> = Lazy::new(|| Regex::new(r"^[a-zA-Z0-9_]+$").unwrap());
+static IS_VALID_PATH_SEGMENT: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^[a-zA-Z0-9_]+$").unwrap());
 
 /// Iterates over all paths in form `a.b[0].c[1]` in alphabetical order
 /// and their corresponding values.

lib/vector-core/src/event/util/log/all_fields.rs

@@ -6,10 +6,10 @@ pub mod transform;
 use std::{
     cmp,
     collections::{HashMap, HashSet},
+    sync::LazyLock,
 };
 
 use async_graphql::{Enum, InputObject, Interface, Object, Subscription};
-use once_cell::sync::Lazy;
 use tokio_stream::{wrappers::BroadcastStream, Stream, StreamExt};
 use vector_lib::internal_event::DEFAULT_OUTPUT;
 
@@ -223,8 +223,8 @@ enum ComponentChanged {
     Removed(Component),
 }
 
-static COMPONENT_CHANGED: Lazy<tokio::sync::broadcast::Sender<ComponentChanged>> =
-    Lazy::new(|| {
+static COMPONENT_CHANGED: LazyLock<tokio::sync::broadcast::Sender<ComponentChanged>> =
+    LazyLock::new(|| {
         let (tx, _) = tokio::sync::broadcast::channel(10);
         tx
     });

src/api/schema/components/mod.rs

@@ -1,17 +1,15 @@
 use std::{
     collections::{HashMap, HashSet},
-    sync::{Arc, RwLock},
+    sync::{Arc, LazyLock, RwLock},
 };
 
-use once_cell::sync::Lazy;
-
 use super::{sink, source, transform, Component};
 use crate::config::{ComponentKey, OutputId};
 
 pub const INVARIANT: &str = "Couldn't acquire lock on Vector components. Please report this.";
 
-pub static COMPONENTS: Lazy<Arc<RwLock<HashMap<ComponentKey, Component>>>> =
-    Lazy::new(|| Arc::new(RwLock::new(HashMap::new())));
+pub static COMPONENTS: LazyLock<Arc<RwLock<HashMap<ComponentKey, Component>>>> =
+    LazyLock::new(|| Arc::new(RwLock::new(HashMap::new())));
 
 /// Filter components with the provided `map_func`
 pub fn filter_components<T>(map_func: impl Fn((&ComponentKey, &Component)) -> Option<T>) -> Vec<T> {

src/api/schema/components/state.rs

@@ -1,9 +1,9 @@
 #![allow(missing_docs)]
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::{num::NonZeroUsize, path::PathBuf, process::ExitStatus, time::Duration};
 
 use exitcode::ExitCode;
 use futures::StreamExt;
-use once_cell::race::OnceNonZeroUsize;
 use tokio::runtime::{self, Runtime};
 use tokio::sync::{broadcast::error::RecvError, MutexGuard};
 use tokio_stream::wrappers::UnboundedReceiverStream;
@@ -30,7 +30,11 @@ use std::os::unix::process::ExitStatusExt;
 use std::os::windows::process::ExitStatusExt;
 use tokio::runtime::Handle;
 
-pub static WORKER_THREADS: OnceNonZeroUsize = OnceNonZeroUsize::new();
+static WORKER_THREADS: AtomicUsize = AtomicUsize::new(0);
+
+pub fn worker_threads() -> Option<NonZeroUsize> {
+    NonZeroUsize::new(WORKER_THREADS.load(Ordering::Relaxed))
+}
 
 pub struct ApplicationConfig {
     pub config_paths: Vec<config::ConfigPath>,
@@ -451,14 +455,14 @@ pub fn build_runtime(threads: Option<usize>, thread_name: &str) -> Result<Runtim
     rt_builder.enable_all().thread_name(thread_name);
 
     let threads = threads.unwrap_or_else(crate::num_threads);
-    let threads = NonZeroUsize::new(threads).ok_or_else(|| {
+    if threads == 0 {
         error!("The `threads` argument must be greater or equal to 1.");
-        exitcode::CONFIG
-    })?;
+        return Err(exitcode::CONFIG);
+    }
     WORKER_THREADS
-        .set(threads)
-        .expect("double thread initialization");
-    rt_builder.worker_threads(threads.get());
+        .compare_exchange(0, threads, Ordering::Acquire, Ordering::Relaxed)
+        .unwrap_or_else(|_| panic!("double thread initialization"));
+    rt_builder.worker_threads(threads);
 
     debug!(messaged = "Building runtime.", worker_threads = threads);
     Ok(rt_builder.build().expect("Unable to create async runtime"))