add SQLD_CONNECTION_CREATION_TIMEOUT_SEC and SQLD_DISABLE_INTELLIGENT_THROTTLING env vars

Author: sivukhin

libsql-server/src/config.rs

@@ -101,6 +101,8 @@ pub struct DbConfig {
     pub snapshot_at_shutdown: bool,
     pub encryption_config: Option<EncryptionConfig>,
     pub max_concurrent_requests: u64,
+    pub disable_intelligent_throttling: bool,
+    pub connection_creation_timeout: Option<Duration>,
 }
 
 impl Default for DbConfig {
@@ -119,6 +121,8 @@ impl Default for DbConfig {
             snapshot_at_shutdown: false,
             encryption_config: None,
             max_concurrent_requests: 128,
+            disable_intelligent_throttling: false,
+            connection_creation_timeout: None,
         }
     }
 }

libsql-server/src/connection/mod.rs

@@ -206,6 +206,7 @@ pub trait MakeConnection: Send + Sync + 'static {
         timeout: Option<Duration>,
         max_total_response_size: u64,
         max_concurrent_requests: u64,
+        disable_intelligent_throttling: bool,
     ) -> MakeThrottledConnection<Self>
     where
         Self: Sized,
@@ -216,6 +217,7 @@ pub trait MakeConnection: Send + Sync + 'static {
             timeout,
             max_total_response_size,
             max_concurrent_requests,
+            disable_intelligent_throttling,
         )
     }
 
@@ -281,6 +283,7 @@ pub struct MakeThrottledConnection<F> {
     max_total_response_size: u64,
     waiters: AtomicUsize,
     max_concurrent_requests: u64,
+    disable_intelligent_throttling: bool,
 }
 
 impl<F> MakeThrottledConnection<F> {
@@ -290,6 +293,7 @@ impl<F> MakeThrottledConnection<F> {
         timeout: Option<Duration>,
         max_total_response_size: u64,
         max_concurrent_requests: u64,
+        disable_intelligent_throttling: bool,
     ) -> Self {
         Self {
             semaphore,
@@ -298,12 +302,16 @@ impl<F> MakeThrottledConnection<F> {
             max_total_response_size,
             waiters: AtomicUsize::new(0),
             max_concurrent_requests,
+            disable_intelligent_throttling,
         }
     }
 
     // How many units should be acquired from the semaphore,
     // depending on current memory pressure.
     fn units_to_take(&self) -> u32 {
+        if self.disable_intelligent_throttling {
+            return 1;
+        }
         let total_response_size = crate::query_result_builder::TOTAL_RESPONSE_SIZE
             .load(std::sync::atomic::Ordering::Relaxed) as u64;
         if total_response_size * 2 > self.max_total_response_size {
@@ -522,6 +530,7 @@ pub mod test {
             Some(Duration::from_millis(100)),
             u64::MAX,
             u64::MAX,
+            false,
         );
 
         let mut conns = Vec::with_capacity(10);

libsql-server/src/lib.rs

@@ -634,6 +634,8 @@ where
             max_concurrent_connections: Arc::new(Semaphore::new(self.max_concurrent_connections)),
             max_concurrent_requests: self.db_config.max_concurrent_requests,
             encryption_config: self.db_config.encryption_config.clone(),
+            disable_intelligent_throttling: self.db_config.disable_intelligent_throttling,
+            connection_creation_timeout: self.db_config.connection_creation_timeout,
         };
 
         let (metastore_conn_maker, meta_store_wal_manager) =

libsql-server/src/main.rs

@@ -248,6 +248,13 @@ struct Cli {
     #[clap(long, default_value = "128", env = "SQLD_MAX_CONCURRENT_REQUESTS")]
     max_concurrent_requests: u64,
 
+    // disable throttling logic which adjust concurrency limits based on memory-pressure conditions
+    #[clap(long, env = "SQLD_DISABLE_INTELLIGENT_THROTTLING")]
+    disable_intelligent_throttling: bool,
+
+    #[clap(long, env = "SQLD_CONNECTION_CREATION_TIMEOUT_SEC")]
+    connection_creation_timeout_sec: Option<u64>,
+
     /// Allow meta store to recover config from filesystem from older version, if meta store is
     /// empty on startup
     #[clap(long, env = "SQLD_ALLOW_METASTORE_RECOVERY")]
@@ -421,6 +428,10 @@ fn make_db_config(config: &Cli) -> anyhow::Result<DbConfig> {
         snapshot_at_shutdown: config.snapshot_at_shutdown,
         encryption_config: encryption_config.clone(),
         max_concurrent_requests: config.max_concurrent_requests,
+        disable_intelligent_throttling: config.disable_intelligent_throttling,
+        connection_creation_timeout: config
+            .connection_creation_timeout_sec
+            .map(|x| Duration::from_secs(x)),
     })
 }
 

libsql-server/src/namespace/configurator/helpers.rs

@@ -180,9 +180,12 @@ pub(super) async fn make_primary_connection_maker(
         .await?
         .throttled(
             base_config.max_concurrent_connections.clone(),
-            Some(DB_CREATE_TIMEOUT),
+            base_config
+                .connection_creation_timeout
+                .or(Some(DB_CREATE_TIMEOUT)),
             base_config.max_total_response_size,
             base_config.max_concurrent_requests,
+            base_config.disable_intelligent_throttling,
         ),
     );
 

libsql-server/src/namespace/configurator/libsql_primary.rs

@@ -118,9 +118,12 @@ pub(super) async fn libsql_primary_common(
     }
     .throttled(
         base_config.max_concurrent_connections.clone(),
-        Some(DB_CREATE_TIMEOUT),
+        base_config
+            .connection_creation_timeout
+            .or(Some(DB_CREATE_TIMEOUT)),
         base_config.max_total_response_size,
         base_config.max_concurrent_requests,
+        base_config.disable_intelligent_throttling,
     );
     let connection_maker = Arc::new(connection_maker);
 

libsql-server/src/namespace/configurator/libsql_replica.rs

@@ -170,9 +170,12 @@ impl ConfigureNamespace for LibsqlReplicaConfigurator {
                 )
                 .throttled(
                     self.base.max_concurrent_connections.clone(),
-                    Some(DB_CREATE_TIMEOUT),
+                    self.base
+                        .connection_creation_timeout
+                        .or(Some(DB_CREATE_TIMEOUT)),
                     self.base.max_total_response_size,
                     self.base.max_concurrent_requests,
+                    self.base.disable_intelligent_throttling,
                 ),
             );
 

libsql-server/src/namespace/configurator/mod.rs

@@ -46,6 +46,8 @@ pub struct BaseNamespaceConfig {
     pub(crate) max_concurrent_connections: Arc<Semaphore>,
     pub(crate) max_concurrent_requests: u64,
     pub(crate) encryption_config: Option<EncryptionConfig>,
+    pub(crate) disable_intelligent_throttling: bool,
+    pub(crate) connection_creation_timeout: Option<Duration>,
 }
 
 #[derive(Clone)]

libsql-server/src/namespace/configurator/replica.rs

@@ -253,9 +253,12 @@ impl ConfigureNamespace for ReplicaConfigurator {
                 )
                 .throttled(
                     self.base.max_concurrent_connections.clone(),
-                    Some(DB_CREATE_TIMEOUT),
+                    self.base
+                        .connection_creation_timeout
+                        .or(Some(DB_CREATE_TIMEOUT)),
                     self.base.max_total_response_size,
                     self.base.max_concurrent_requests,
+                    self.base.disable_intelligent_throttling,
                 ),
             );