Spell "committer" with two Ts in our codebase (#27151)

I'll duplicate all the existing knobs in production to have both one and two Ts before landing this.

GitOrigin-RevId: 7e6a8d502e076dff4f400281ef080d99b3d09bf9

Author: Sujay Jayakar

crates/common/src/knobs.rs

@@ -575,14 +575,14 @@ pub static DATABASE_UDF_SYSTEM_TIMEOUT: LazyLock<Duration> =
 pub static ISOLATE_QUEUE_SIZE: LazyLock<usize> =
     LazyLock::new(|| env_config("ISOLATE_QUEUE_SIZE", 2000));
 
-/// The size of the pending commits in the commiter queue. This is a FIFO queue,
-/// so if the queue is too large, we run into a risk of all requests waiting too
-/// long and no requests going through during overload. The size of each commit
-/// request is also typically larger than a isolate request. For time being,
-/// allow 128 slots, which is the maximum number of isolate threads in
-/// any process.
-pub static COMMITER_QUEUE_SIZE: LazyLock<usize> =
-    LazyLock::new(|| env_config("COMMITER_QUEUE_SIZE", 128));
+/// The size of the pending commits in the committer queue. This is a FIFO
+/// queue, so if the queue is too large, we run into a risk of all requests
+/// waiting too long and no requests going through during overload. The size of
+/// each commit request is also typically larger than a isolate request. For
+/// time being, allow 128 slots, which is the maximum number of isolate threads
+/// in any process.
+pub static COMMITTER_QUEUE_SIZE: LazyLock<usize> =
+    LazyLock::new(|| env_config("COMMITTER_QUEUE_SIZE", 128));
 
 /// 0 -> default (number of cores)
 pub static V8_THREADS: LazyLock<u32> = LazyLock::new(|| env_config("V8_THREADS", 0));

crates/database/src/committer.rs

@@ -22,7 +22,7 @@ use common::{
     },
     errors::recapture_stacktrace,
     knobs::{
-        COMMITER_QUEUE_SIZE,
+        COMMITTER_QUEUE_SIZE,
         MAX_REPEATABLE_TIMESTAMP_COMMIT_DELAY,
         MAX_REPEATABLE_TIMESTAMP_IDLE_FREQUENCY,
     },
@@ -174,7 +174,7 @@ impl<RT: Runtime> Committer<RT> {
     ) -> CommitterClient<RT> {
         let persistence_reader = persistence.reader();
         let conflict_checker = PendingWrites::new(persistence_reader.version());
-        let (tx, rx) = mpsc::channel(*COMMITER_QUEUE_SIZE);
+        let (tx, rx) = mpsc::channel(*COMMITTER_QUEUE_SIZE);
         let snapshot_reader = snapshot_manager.reader();
         let committer = Self {
             pending_writes: conflict_checker,

crates/usage_tracking/src/lib.rs

@@ -519,9 +519,9 @@ impl StorageUsageTracker for UsageCounter {
 #[derive(Debug, Clone)]
 pub struct FunctionUsageTracker {
     // TODO: We should ideally not use an Arc<Mutex> here. The best way to achieve
-    // this is to move the logic for accounting ingress out of the Commiter into
+    // this is to move the logic for accounting ingress out of the Committer into
     // the Transaction. Then Transaction can solely own the counters and we can
-    // remove clone(). The alternative is for the Commiter to take ownership of
+    // remove clone(). The alternative is for the Committer to take ownership of
     // the usage tracker and then return it, but this will make it complicated if
     // we later decide to charge people for OCC bandwidth.
     state: Arc<Mutex<FunctionUsageStats>>,