Try to adapt to rand API changes

Author: def-

Cargo.lock

@@ -335,7 +335,7 @@ impl Coordinator {
             EpochMillis::try_from(self.storage_usage_collection_interval.as_millis())
                 .expect("storage usage collection interval must fit into u64");
         let offset =
-            rngs::SmallRng::from_seed(seed).gen_range(0..storage_usage_collection_interval_ms);
+            rngs::SmallRng::from_seed(seed).random_range(0..storage_usage_collection_interval_ms);
         let now_ts: EpochMillis = self.peek_local_write_ts().await.into();
 
         // 2) Determine the amount of ms between now and the next collection time.

src/adapter/src/coord/message_handler.rs

@@ -26,7 +26,7 @@ use mz_sql_parser::ast::{statement_kind_label_value, StatementKind};
 use mz_storage_client::controller::IntrospectionType;
 use qcell::QCell;
 use rand::SeedableRng;
-use rand::{distributions::Bernoulli, prelude::Distribution, thread_rng};
+use rand::{distr::Bernoulli, prelude::Distribution, rng};
 use sha2::{Digest, Sha256};
 use tokio::time::MissedTickBehavior;
 use tracing::debug;
@@ -131,7 +131,7 @@ pub(crate) struct StatementLogging {
     unlogged_sessions: BTreeMap<Uuid, SessionHistoryEvent>,
 
     /// A reproducible RNG for deciding whether to sample statement executions.
-    /// Only used by tests; otherwise, `rand::thread_rng()` is used.
+    /// Only used by tests; otherwise, `rand::rng()` is used.
     /// Controlled by the system var `statement_logging_use_reproducible_rng`.
     reproducible_rng: rand_chacha::ChaCha8Rng,
 
@@ -682,7 +682,7 @@ impl Coordinator {
         {
             distribution.sample(&mut self.statement_logging.reproducible_rng)
         } else {
-            distribution.sample(&mut thread_rng())
+            distribution.sample(&mut rng())
         };
 
         // Track how many statements we're recording.

src/adapter/src/coord/statement_logging.rs

@@ -328,7 +328,7 @@ impl<T: TimestampManipulation> Session<T> {
             notices_tx,
             notices_rx,
             next_transaction_id: 0,
-            secret_key: rand::thread_rng().gen(),
+            secret_key: rand::rng().random(),
             external_metadata_rx,
             qcell_owner: QCellOwner::new(),
             session_oracles: BTreeMap::new(),

src/adapter/src/session.rs

@@ -382,8 +382,8 @@ impl Fingerprint for &BuiltinTable {
                 format!("{}{}", self.desc.fingerprint(), whitespace)
             }
             Some((UnsafeBuiltinTableFingerprintWhitespace::Half, whitespace)) => {
-                let mut rng = rand::thread_rng();
-                let migrate: bool = rng.gen();
+                let mut rng = rand::rng();
+                let migrate: bool = rng.random();
                 if migrate {
                     format!("{}{}", self.desc.fingerprint(), whitespace)
                 } else {

src/catalog/src/builtin.rs

@@ -16,7 +16,7 @@ futures = "0.3.25"
 k8s-openapi = { version = "0.22.0", features = ["schemars", "v1_29"] }
 kube = { version = "0.92.1", default-features = false, features = ["client", "derive", "openssl-tls", "ws"] }
 mz-ore = { path = "../ore", default-features = false }
-rand = "0.9.0"
+rand = "0.8.5"
 schemars = { version = "0.8", features = ["uuid1"] }
 semver = "1.0.16"
 serde = "1.0.152"

src/cloud-resources/Cargo.toml

@@ -2970,7 +2970,7 @@ fn test_invalid_webhook_body() {
 
     // No matter what is in the body, we should always succeed.
     let mut data = [0u8; 128];
-    rand::thread_rng().fill_bytes(&mut data);
+    rand::rng().fill_bytes(&mut data);
     println!("Random bytes: {data:?}");
     let resp = http_client
         .post(webhook_url)

src/environmentd/tests/server.rs

@@ -14,7 +14,7 @@ use criterion::{criterion_group, criterion_main, Criterion};
 use mz_expr::ColumnOrder;
 use mz_repr::adt::timestamp::CheckedTimestamp;
 use mz_repr::{Datum, RowArena};
-use rand::distributions::{Distribution, Uniform};
+use rand::distr::{Distribution, Uniform};
 
 /// Microbenchmark to test an important part of window function evaluation.
 ///
@@ -53,7 +53,7 @@ fn order_aggregate_datums_benchmark(c: &mut Criterion) {
     let scale = 1000000;
 
     group.bench_function("order_aggregate_datums", |b| {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let temp_storage = RowArena::new();
 
         let order_by = vec![ColumnOrder {

src/expr/benches/window_functions.rs

@@ -23,10 +23,11 @@ use mz_kafka_util::client::MzClientContext;
 use mz_ore::cast::CastFrom;
 use mz_ore::cli::{self, CliConfig};
 use mz_ore::retry::Retry;
-use rand::distributions::uniform::SampleUniform;
-use rand::distributions::{Alphanumeric, Bernoulli, Uniform, WeightedIndex};
+use rand::distr::uniform::SampleUniform;
+use rand::distr::weighted::WeightedIndex;
+use rand::distr::{Alphanumeric, Bernoulli, Uniform};
 use rand::prelude::{Distribution, ThreadRng};
-use rand::thread_rng;
+use rand::rng;
 use rdkafka::error::KafkaError;
 use rdkafka::producer::{BaseRecord, Producer, ThreadedProducer};
 use rdkafka::types::RDKafkaErrorCode;
@@ -247,21 +248,21 @@ impl<'a> RandomAvroGenerator<'a> {
                 x[0].as_i64().unwrap().try_into().unwrap(),
                 x[1].as_i64().unwrap().try_into().unwrap(),
             );
-            let dist = Uniform::new_inclusive(min, max);
+            let dist = Uniform::new_inclusive(min, max).unwrap();
             move |rng| dist.sample(rng)
         }
         fn float_dist(json: &serde_json::Value) -> impl FnMut(&mut ThreadRng) -> f32 + Clone {
             let x = json.as_array().unwrap();
             // TODO(benesch): rewrite to avoid `as`.
             #[allow(clippy::as_conversions)]
             let (min, max) = (x[0].as_f64().unwrap() as f32, x[1].as_f64().unwrap() as f32);
-            let dist = Uniform::new_inclusive(min, max);
+            let dist = Uniform::new_inclusive(min, max).unwrap();
             move |rng| dist.sample(rng)
         }
         fn double_dist(json: &serde_json::Value) -> impl FnMut(&mut ThreadRng) -> f64 + Clone {
             let x = json.as_array().unwrap();
             let (min, max) = (x[0].as_f64().unwrap(), x[1].as_f64().unwrap());
-            let dist = Uniform::new_inclusive(min, max);
+            let dist = Uniform::new_inclusive(min, max).unwrap();
             move |rng| dist.sample(rng)
         }
         fn string_dist(json: &serde_json::Value) -> impl FnMut(&mut ThreadRng) -> Vec<u8> + Clone {
@@ -276,7 +277,7 @@ impl<'a> RandomAvroGenerator<'a> {
             let mut len = integral_dist::<usize>(json);
             move |rng| {
                 let len = len(rng);
-                let bd = Uniform::new_inclusive(0, 255);
+                let bd = Uniform::new_inclusive(0, 255).unwrap();
                 iter::repeat_with(|| bd.sample(rng)).take(len).collect()
             }
         }
@@ -302,7 +303,7 @@ impl<'a> RandomAvroGenerator<'a> {
                 min,
                 precision
             );
-            let dist = Uniform::<i64>::new_inclusive(min, max);
+            let dist = Uniform::<i64>::new_inclusive(min, max).unwrap();
             move |rng| dist.sample(rng).to_be_bytes().to_vec()
         }
         // TODO(benesch): rewrite to avoid `as`.
@@ -602,8 +603,9 @@ async fn main() -> anyhow::Result<()> {
                 bail!("cannot specify --avro-distribution without --values=avro");
             }
             let len =
-                Uniform::new_inclusive(args.min_value_size.unwrap(), args.max_value_size.unwrap());
-            let bytes = Uniform::new_inclusive(0, 255);
+                Uniform::new_inclusive(args.min_value_size.unwrap(), args.max_value_size.unwrap())
+                    .unwrap();
+            let bytes = Uniform::new_inclusive(0, 255).unwrap();
 
             ValueGenerator::UniformBytes { len, bytes }
         }
@@ -677,10 +679,7 @@ async fn main() -> anyhow::Result<()> {
         }
     };
     let key_dist = if let KeyFormat::Random = args.key_format {
-        Some(Uniform::new_inclusive(
-            args.key_min.unwrap(),
-            args.key_max.unwrap(),
-        ))
+        Some(Uniform::new_inclusive(args.key_min.unwrap(), args.key_max.unwrap()).unwrap())
     } else {
         None
     };
@@ -711,7 +710,7 @@ async fn main() -> anyhow::Result<()> {
                 n += 1;
             }
             scope.spawn(move |_| {
-                let mut rng = thread_rng();
+                let mut rng = rng();
                 for _ in 0..n {
                     let i = counter.fetch_add(1, Ordering::Relaxed);
                     if !args.quiet && i % 100_000 == 0 {

src/kafka-util/src/bin/kgen.rs

@@ -30,7 +30,7 @@ use k8s_openapi::{
 };
 use kube::{api::ObjectMeta, runtime::controller::Action, Api, Client, ResourceExt};
 use maplit::btreemap;
-use rand::{thread_rng, Rng};
+use rand::{rng, Rng};
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
 use tracing::trace;
@@ -175,7 +175,7 @@ impl Resources {
         // promotion step, this will no longer make a difference and we can
         // remove the extra codepath.
         if increment_generation {
-            let retry_action = Action::requeue(Duration::from_secs(thread_rng().gen_range(5..10)));
+            let retry_action = Action::requeue(Duration::from_secs(rng().random_range(5..10)));
 
             let statefulset = get_resource(
                 &statefulset_api,