itsi-scheduler 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4608db7a6227b55d8ecea4a46ad9c4ff8b1df83ac3c563ceb05959921b66c1ab
-  data.tar.gz: 8a80d6ad6054e9299bec4ebe67fef75abd0e969141a613faedf4e3e24aa653af
+  metadata.gz: '06169b51c9344ad3892f08cf099c459f9bea7377d7e7b3342a54b9314e7f0c8f'
+  data.tar.gz: d18702aac863d7bf49c100cbcd0be525031d8ed7f334368d507c9ffee53abcbd
 SHA512:
-  metadata.gz: 3ddac9d8deb50306d4a25304a522361f8cad05a82e88a77fbe6899a2675d5a2c8c306967a0376190bb9b34883ffd2677ec6e3f9e03fd1bb85bc8ea07396a8053
-  data.tar.gz: 8644d0da8994fd68e938b257e76e56d00b2ee9d9784010ddcde6bb2454e776949af666ec7525b75800b7a80658d2092769ccca4c6979a3ec5beae77389949edf
+  metadata.gz: 54a585ef25065bcf8e038a87d80a214a1a17aac9f5510a083d6598928d48c879866d89723c399473faf8ef96f8464a5c2b0b3f3d0d24cdc551e11aae9574b9fe
+  data.tar.gz: 3c102f1994d0c6beee8473261fe49a206addcd04f80afdc09a0eaf8ebf6d31f738cbfbc4afa00dff0d9790a65fa426e0bd7e34c4e7f341231a9b4c036bc0583d

data/ext/itsi_rb_helpers/src/lib.rs

@@ -1,7 +1,8 @@
-use std::{os::raw::c_void, ptr::null_mut, sync::Arc};
+use std::{os::raw::c_void, ptr::null_mut};
 
 use magnus::{
     RArray, Ruby, Thread, Value,
+    block::Proc,
     rb_sys::FromRawValue,
     value::{LazyId, ReprValue},
 };
@@ -17,6 +18,7 @@ static ID_LIST: LazyId = LazyId::new("list");
 static ID_EQ: LazyId = LazyId::new("==");
 static ID_ALIVE: LazyId = LazyId::new("alive?");
 static ID_THREAD_VARIABLE_GET: LazyId = LazyId::new("thread_variable_get");
+static ID_BACKTRACE: LazyId = LazyId::new("backtrace");
 
 pub fn schedule_thread() {
     unsafe {
@@ -120,20 +122,30 @@ where
     *result_box
 }
 
-pub fn fork(after_fork: Arc<Option<impl Fn()>>) -> Option<i32> {
+pub fn fork(after_fork: Option<HeapValue<Proc>>) -> Option<i32> {
     let ruby = Ruby::get().unwrap();
     let fork_result = ruby
         .module_kernel()
         .funcall::<_, _, Option<i32>>(*ID_FORK, ())
         .unwrap();
     if fork_result.is_none() {
-        if let Some(f) = &*after_fork {
-            f()
+        if let Some(proc) = after_fork {
+            call_proc_and_log_errors(proc)
         }
     }
     fork_result
 }
 
+pub fn call_proc_and_log_errors(proc: HeapValue<Proc>) {
+    if let Err(e) = proc.call::<_, Value>(()) {
+        if let Some(value) = e.value() {
+            print_rb_backtrace(value);
+        } else {
+            eprintln!("Error occurred {:?}", e);
+        }
+    }
+}
+
 pub fn kill_threads<T>(threads: Vec<T>)
 where
     T: ReprValue,
@@ -176,3 +188,14 @@ pub fn terminate_non_fork_safe_threads() {
 
     kill_threads(non_fork_safe_threads);
 }
+
+pub fn print_rb_backtrace(rb_err: Value) {
+    let backtrace = rb_err
+        .funcall::<_, _, Vec<String>>(*ID_BACKTRACE, ())
+        .unwrap_or_default();
+
+    eprintln!("Ruby exception {:?}", rb_err);
+    for line in backtrace {
+        eprintln!("{}", line);
+    }
+}

data/ext/itsi_server/Cargo.toml

@@ -24,7 +24,7 @@ rcgen = { version = "0.13.2", features = ["x509-parser", "pem"] }
 base64 = "0.22.1"
 http-body-util = "0.1.2"
 hyper = { version = "1.5.0", features = ["full", "server", "http1", "http2"] }
-tokio = { version = "1", features = ["full"] }
+tokio = { version = "1.44.1", features = ["full"] }
 hyper-util = { version = "0.1.10", features = ["full"] }
 derive_more = { version = "2.0.1", features = ["debug"] }
 http = "1.3.1"
@@ -45,3 +45,6 @@ fs2 = "0.4.3"
 ring = "0.17.14"
 async-trait = "0.1.87"
 dirs = "6.0.0"
+regex = "1.11.1"
+route-recognizer = "0.3.1"
+fnv = "1.0.7"

data/ext/itsi_server/src/lib.rs

@@ -1,5 +1,8 @@
 use body_proxy::itsi_body_proxy::ItsiBodyProxy;
-use magnus::{error::Result, function, method, value::Lazy, Module, Object, RClass, RModule, Ruby};
+use magnus::{
+    error::Result, function, method, value::Lazy, Module, Object, RClass, RHash, RModule, Ruby,
+};
+use regex::{Regex, RegexSet};
 use request::itsi_request::ItsiRequest;
 use response::itsi_response::ItsiResponse;
 use server::{itsi_server::Server, signal::reset_signal_handlers};
@@ -54,6 +57,70 @@ pub fn log_error(msg: String) {
     error!(msg);
 }
 
+const ROUTES: [&str; 39] = [
+    r"(?-u)^/organisations/(?<organisation_id>\d+)/users/(?<user_id>\d+)$",
+    r"(?-u)^/projects/(?<project_id>\d+)/tasks/(?<task_id>\d+)$",
+    r"(?-u)^/products/(?<product_id>\d+)(?:/reviews/(?<review_id>\d+))?$",
+    r"(?-u)^/orders/(?<order_id>\d+)/items(?:/(?<item_id>\d+))?$",
+    r"(?-u)^/posts/(?<post_id>\d+)/comments(?:/(?<comment_id>\d+))?$",
+    r"(?-u)^/teams/(?<team_id>\d+)(?:/members/(?<member_id>\d+))?$",
+    r"(?-u)^/categories/(?<category_id>\d+)/subcategories(?:/(?<subcategory_id>\d+))?$",
+    r"(?-u)^/departments/(?<department_id>\d+)/employees/(?<employee_id>\d+)$",
+    r"(?-u)^/events/(?<event_id>\d+)(?:/sessions/(?<session_id>\d+))?$",
+    r"(?-u)^/invoices/(?<invoice_id>\d+)/payments(?:/(?<payment_id>\d+))?$",
+    r"(?-u)^/tickets/(?<ticket_id>\d+)(?:/responses/(?<response_id>\d+))?$",
+    r"(?-u)^/forums/(?<forum_id>\d+)(?:/threads/(?<thread_id>\d+))?$",
+    r"(?-u)^/subscriptions/(?<subscription_id>\d+)/plans(?:/(?<plan_id>\d+))?$",
+    r"(?-u)^/profiles/(?<profile_id>\d+)/settings$",
+    r"(?-u)^/organizations/(?<organization_id>\d+)/billing(?:/(?<billing_id>\d+))?$",
+    r"(?-u)^/vendors/(?<vendor_id>\d+)/products(?:/(?<product_id>\d+))?$",
+    r"(?-u)^/courses/(?<course_id>\d+)/modules(?:/(?<module_id>\d+))?$",
+    r"(?-u)^/accounts/(?<account_id>\d+)(?:/transactions/(?<transaction_id>\d+))?$",
+    r"(?-u)^/warehouses/(?<warehouse_id>\d+)/inventory(?:/(?<inventory_id>\d+))?$",
+    r"(?-u)^/campaigns/(?<campaign_id>\d+)/ads(?:/(?<ad_id>\d+))?$",
+    r"(?-u)^/applications/(?<application_id>\d+)/stages(?:/(?<stage_id>\d+))?$",
+    r"(?-u)^/notifications/(?<notification_id>\d+)$",
+    r"(?-u)^/albums/(?<album_id>\d+)/photos(?:/(?<photo_id>\d+))?$",
+    r"(?-u)^/news/(?<news_id>\d+)/articles(?:/(?<article_id>\d+))?$",
+    r"(?-u)^/libraries/(?<library_id>\d+)/books(?:/(?<book_id>\d+))?$",
+    r"(?-u)^/universities/(?<university_id>\d+)/students(?:/(?<student_id>\d+))?$",
+    r"(?-u)^/banks/(?<bank_id>\d+)/branches(?:/(?<branch_id>\d+))?$",
+    r"(?-u)^/vehicles/(?<vehicle_id>\d+)/services(?:/(?<service_id>\d+))?$",
+    r"(?-u)^/hotels/(?<hotel_id>\d+)/rooms(?:/(?<room_id>\d+))?$",
+    r"(?-u)^/doctors/(?<doctor_id>\d+)/appointments(?:/(?<appointment_id>\d+))?$",
+    r"(?-u)^/gyms/(?<gym_id>\d+)/memberships(?:/(?<membership_id>\d+))?$",
+    r"(?-u)^/restaurants/(?<restaurant_id>\d+)/menus(?:/(?<menu_id>\d+))?$",
+    r"(?-u)^/parks/(?<park_id>\d+)/events(?:/(?<event_id>\d+))?$",
+    r"(?-u)^/theaters/(?<theater_id>\d+)/shows(?:/(?<show_id>\d+))?$",
+    r"(?-u)^/museums/(?<museum_id>\d+)/exhibits(?:/(?<exhibit_id>\d+))?$",
+    r"(?-u)^/stadiums/(?<stadium_id>\d+)/games(?:/(?<game_id>\d+))?$",
+    r"(?-u)^/schools/(?<school_id>\d+)/classes(?:/(?<class_id>\d+))?$",
+    r"(?-u)^/clubs/(?<club_id>\d+)/events(?:/(?<event_id>\d+))?$",
+    r"(?-u)^/festivals/(?<festival_id>\d+)/tickets(?:/(?<ticket_id>\d+))?$",
+];
+use std::sync::LazyLock;
+
+static REGEX_SET: LazyLock<RegexSet> = LazyLock::new(|| RegexSet::new(ROUTES).unwrap());
+static REGEXES: LazyLock<Vec<Regex>> =
+    LazyLock::new(|| ROUTES.iter().map(|&r| Regex::new(r).unwrap()).collect());
+
+fn match_route(input: String) -> Result<Option<(usize, Option<RHash>)>> {
+    if let Some(index) = REGEX_SET.matches(&input).iter().next() {
+        let regex = &REGEXES[index];
+        if let Some(captures) = regex.captures(&input) {
+            let params = RHash::with_capacity(captures.len());
+            for name in regex.capture_names().flatten() {
+                if let Some(value) = captures.name(name) {
+                    params.aset(name, value.as_str()).ok();
+                }
+            }
+            return Ok(Some((index, Some(params))));
+        }
+        return Ok(Some((index, None)));
+    }
+    Ok(None)
+}
+
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<()> {
     itsi_tracing::init();
@@ -62,6 +129,7 @@ fn init(ruby: &Ruby) -> Result<()> {
         .ok();
 
     let itsi = ruby.get_inner(&ITSI_MODULE);
+    itsi.define_singleton_method("match_route", function!(match_route, 1))?;
     itsi.define_singleton_method("log_debug", function!(log_debug, 1))?;
     itsi.define_singleton_method("log_info", function!(log_info, 1))?;
     itsi.define_singleton_method("log_warn", function!(log_warn, 1))?;

data/ext/itsi_server/src/request/itsi_request.rs

@@ -17,6 +17,7 @@ use http::{request::Parts, HeaderValue, Response, StatusCode};
 use http_body_util::{combinators::BoxBody, BodyExt, Empty};
 use hyper::{body::Incoming, Request};
 use itsi_error::from::CLIENT_CONNECTION_CLOSED;
+use itsi_rb_helpers::print_rb_backtrace;
 use itsi_tracing::{debug, error};
 use magnus::{
     error::{ErrorType, Result as MagnusResult},
@@ -33,7 +34,6 @@ use tokio::sync::{
 };
 static ID_CALL: LazyId = LazyId::new("call");
 static ID_MESSAGE: LazyId = LazyId::new("message");
-static ID_BACKTRACE: LazyId = LazyId::new("backtrace");
 
 #[derive(Debug)]
 #[magnus::wrap(class = "Itsi::Request", free_immediately, size)]
@@ -115,14 +115,7 @@ impl ItsiRequest {
             debug!("Connection closed by client");
             response.close();
         } else if let Some(rb_err) = err.value() {
-            let backtrace = rb_err
-                .funcall::<_, _, Vec<String>>(*ID_BACKTRACE, ())
-                .unwrap_or_default();
-
-            error!("Error occurred in Handler: {:?}", rb_err);
-            for line in backtrace {
-                error!("{}", line);
-            }
+            print_rb_backtrace(rb_err);
             response.internal_server_error(err.to_string());
         } else {
             response.internal_server_error(err.to_string());

data/ext/itsi_server/src/response/itsi_response.rs

@@ -77,7 +77,6 @@ impl ItsiResponse {
                 (ReceiverStream::new(receiver), shutdown_rx),
                 |(mut receiver, mut shutdown_rx)| async move {
                     if let RunningPhase::ShutdownPending = *shutdown_rx.borrow() {
-                        warn!("Disconnecting streaming client.");
                         return None;
                     }
                     loop {
@@ -280,7 +279,8 @@ impl ItsiResponse {
         if let Some(writer) = writer.write().as_ref() {
             writer
                 .blocking_send(Some(frame))
-                .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)?;
+                .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)
+                .ok();
         }
         Ok(0)
     }

data/ext/itsi_server/src/server/bind.rs

@@ -101,7 +101,7 @@ impl FromStr for Bind {
                     "IPv6 addresses must use [ ] when specifying a port".to_owned(),
                 ));
             } else {
-                (h, None) // Treat as a hostname
+                (h, p.parse::<u16>().ok()) // Treat as a hostname
             }
         } else {
             (url, None)
@@ -110,18 +110,22 @@ impl FromStr for Bind {
         let address = if let Ok(ip) = host.parse::<IpAddr>() {
             BindAddress::Ip(ip)
         } else {
-            resolve_hostname(host)
-                .map(BindAddress::Ip)
-                .ok_or(ItsiError::ArgumentError(format!(
-                    "Failed to resolve hostname {}",
-                    host
-                )))?
+            match protocol {
+                BindProtocol::Https | BindProtocol::Http => resolve_hostname(host)
+                    .map(BindAddress::Ip)
+                    .ok_or(ItsiError::ArgumentError(format!(
+                        "Failed to resolve hostname {}",
+                        host
+                    )))?,
+                BindProtocol::Unix | BindProtocol::Unixs => BindAddress::UnixSocket(host.into()),
+            }
         };
-        let (port, address) = match protocol {
-            BindProtocol::Http => (port.or(Some(80)), address),
-            BindProtocol::Https => (port.or(Some(443)), address),
-            BindProtocol::Unix => (None, BindAddress::UnixSocket(host.into())),
-            BindProtocol::Unixs => (None, BindAddress::UnixSocket(host.into())),
+
+        let port = match protocol {
+            BindProtocol::Http => port.or(Some(80)),
+            BindProtocol::Https => port.or(Some(443)),
+            BindProtocol::Unix => None,
+            BindProtocol::Unixs => None,
         };
 
         let tls_config = match protocol {

data/ext/itsi_server/src/server/itsi_server.rs

@@ -8,17 +8,17 @@ use super::{
 };
 use crate::{request::itsi_request::ItsiRequest, server::serve_strategy::ServeStrategy};
 use derive_more::Debug;
-use itsi_rb_helpers::{call_without_gvl, HeapVal};
+use itsi_rb_helpers::{call_without_gvl, HeapVal, HeapValue};
 use itsi_tracing::{error, run_silently};
 use magnus::{
     block::Proc,
     error::Result,
     scan_args::{get_kwargs, scan_args, Args, KwArgs, ScanArgsKw, ScanArgsOpt, ScanArgsRequired},
-    value::{InnerValue, Opaque, ReprValue},
-    ArgList, RHash, Ruby, Symbol, Value,
+    value::ReprValue,
+    ArgList, RArray, RHash, Ruby, Symbol, Value,
 };
 use parking_lot::{Mutex, RwLock};
-use std::{cmp::max, ops::Deref, sync::Arc};
+use std::{cmp::max, collections::HashMap, ops::Deref, sync::Arc};
 use tracing::{info, instrument};
 
 static DEFAULT_BIND: &str = "http://localhost:3000";
@@ -36,7 +36,6 @@ impl Deref for Server {
         &self.config
     }
 }
-type AfterFork = Mutex<Arc<Option<Box<dyn Fn() + Send + Sync>>>>;
 
 #[derive(Debug)]
 pub struct ServerConfig {
@@ -51,15 +50,14 @@ pub struct ServerConfig {
     pub script_name: String,
     pub(crate) binds: Mutex<Vec<Bind>>,
     #[debug(skip)]
-    pub before_fork: Mutex<Option<Box<dyn FnOnce() + Send + Sync>>>,
-    #[debug(skip)]
-    pub after_fork: AfterFork,
+    pub hooks: HashMap<String, HeapValue<Proc>>,
     pub scheduler_class: Option<String>,
     pub stream_body: Option<bool>,
     pub worker_memory_limit: Option<u64>,
     #[debug(skip)]
     pub(crate) strategy: RwLock<Option<ServeStrategy>>,
     pub silence: bool,
+    pub oob_gc_responses_threshold: Option<u64>,
 }
 
 #[derive(Debug)]
@@ -68,8 +66,6 @@ pub enum RequestJob {
     Shutdown,
 }
 
-// Define your helper function.
-// Here P, A, C correspond to the types for the first tuple, second tuple, and extra parameters respectively.
 fn extract_args<Req, Opt, Splat>(
     scan_args: &Args<(), (), (), (), RHash, ()>,
     primaries: &[&str],
@@ -80,20 +76,17 @@ where
     Opt: ScanArgsOpt,
     Splat: ScanArgsKw,
 {
-    // Combine the primary and rest names into one Vec of Symbols.
     let symbols: Vec<Symbol> = primaries
         .iter()
         .chain(rest.iter())
         .map(|&name| Symbol::new(name))
         .collect();
 
-    // Call the "slice" function with the combined symbols.
     let hash = scan_args
         .keywords
         .funcall::<_, _, RHash>("slice", symbols.into_arg_list_with(&Ruby::get().unwrap()))
         .unwrap();
 
-    // Finally, call get_kwargs with the original name slices.
     get_kwargs(hash, primaries, rest)
 }
 
@@ -129,14 +122,14 @@ impl Server {
         type Args2 = KwArgs<
             (),
             (
-                // Before Fork
-                Option<Proc>,
-                // After Fork
-                Option<Proc>,
+                // Hooks
+                Option<RHash>,
                 // Scheduler Class
                 Option<String>,
                 // Worker Memory Limit
                 Option<u64>,
+                // Out-of-band GC Responses Threshold
+                Option<u64>,
                 // Silence
                 Option<bool>,
             ),
@@ -160,14 +153,33 @@ impl Server {
             &scan_args,
             &[],
             &[
-                "before_fork",
-                "after_fork",
+                "hooks",
                 "scheduler_class",
                 "worker_memory_limit",
+                "oob_gc_responses_threshold",
                 "silence",
             ],
         )?;
 
+        let hooks = args2
+            .optional
+            .0
+            .map(|rhash| -> Result<HashMap<String, HeapValue<Proc>>> {
+                let mut hook_map: HashMap<String, HeapValue<Proc>> = HashMap::new();
+                for pair in rhash.enumeratorize::<_, ()>("each", ()) {
+                    if let Some(pair_value) = RArray::from_value(pair?) {
+                        if let (Ok(key), Ok(value)) =
+                            (pair_value.entry::<Value>(0), pair_value.entry::<Proc>(1))
+                        {
+                            hook_map.insert(key.to_string(), HeapValue::from(value));
+                        }
+                    }
+                }
+                Ok(hook_map)
+            })
+            .transpose()?
+            .unwrap_or_default();
+
         let config = ServerConfig {
             app: HeapVal::from(args1.required.0),
             workers: max(args1.optional.0.unwrap_or(1), 1),
@@ -184,32 +196,16 @@ impl Server {
                     .collect::<itsi_error::Result<Vec<Bind>>>()?,
             ),
             stream_body: args1.optional.5,
-            before_fork: Mutex::new(args2.optional.0.map(|p| {
-                let opaque_proc = Opaque::from(p);
-                Box::new(move || {
-                    opaque_proc
-                        .get_inner_with(&Ruby::get().unwrap())
-                        .call::<_, Value>(())
-                        .unwrap();
-                }) as Box<dyn FnOnce() + Send + Sync>
-            })),
-            after_fork: Mutex::new(Arc::new(args2.optional.1.map(|p| {
-                let opaque_proc = Opaque::from(p);
-                Box::new(move || {
-                    opaque_proc
-                        .get_inner_with(&Ruby::get().unwrap())
-                        .call::<_, Value>(())
-                        .unwrap();
-                }) as Box<dyn Fn() + Send + Sync>
-            }))),
-            scheduler_class: args2.optional.2.clone(),
-            worker_memory_limit: args2.optional.3,
-            silence: args2.optional.4.is_some_and(|s| s),
+            hooks,
+            scheduler_class: args2.optional.1.clone(),
+            worker_memory_limit: args2.optional.2,
             strategy: RwLock::new(None),
+            oob_gc_responses_threshold: args2.optional.3,
+            silence: args2.optional.4.is_some_and(|s| s),
         };
 
         if !config.silence {
-            if let Some(scheduler_class) = args2.optional.2 {
+            if let Some(scheduler_class) = args2.optional.1 {
                 info!(scheduler_class, fiber_scheduler = true);
             } else {
                 info!(fiber_scheduler = false);
@@ -222,7 +218,7 @@ impl Server {
     }
 
     #[instrument(name = "Bind", skip_all, fields(binds=format!("{:?}", self.config.binds.lock())))]
-    pub(crate) fn build_listeners(&self) -> Result<Arc<Vec<Arc<Listener>>>> {
+    pub(crate) fn build_listeners(&self) -> Result<Vec<Listener>> {
         let listeners = self
             .config
             .binds
@@ -232,13 +228,13 @@ impl Server {
             .map(Listener::try_from)
             .collect::<std::result::Result<Vec<Listener>, _>>()?
             .into_iter()
-            .map(Arc::new)
             .collect::<Vec<_>>();
         info!("Bound {:?} listeners", listeners.len());
-        Ok(Arc::new(listeners))
+        Ok(listeners)
     }
 
-    pub(crate) fn build_strategy(self, listeners: Arc<Vec<Arc<Listener>>>) -> Result<()> {
+    pub(crate) fn build_strategy(self) -> Result<()> {
+        let listeners = self.build_listeners()?;
         let server = Arc::new(self);
         let server_clone = server.clone();
 
@@ -276,11 +272,9 @@ impl Server {
     fn build_and_run_strategy(&self) -> Result<()> {
         reset_signal_handlers();
         let rself = self.clone();
-        let listeners = self.build_listeners()?;
-        let listeners_clone = listeners.clone();
         call_without_gvl(move || -> Result<()> {
-            rself.clone().build_strategy(listeners_clone)?;
-            if let Err(e) = rself.clone().strategy.read().as_ref().unwrap().run() {
+            rself.clone().build_strategy()?;
+            if let Err(e) = rself.strategy.read().as_ref().unwrap().run() {
                 error!("Error running server: {}", e);
                 rself.strategy.read().as_ref().unwrap().stop()?;
             }

data/ext/itsi_server/src/server/listener.rs

@@ -243,20 +243,20 @@ impl std::fmt::Display for SockAddr {
 }
 
 impl Listener {
-    pub fn to_tokio_listener(&self) -> TokioListener {
+    pub fn into_tokio_listener(self) -> TokioListener {
         match self {
-            Listener::Tcp(listener) => TokioListener::Tcp(
-                TokioTcpListener::from_std(TcpListener::try_clone(listener).unwrap()).unwrap(),
-            ),
+            Listener::Tcp(listener) => {
+                TokioListener::Tcp(TokioTcpListener::from_std(listener).unwrap())
+            }
             Listener::TcpTls((listener, acceptor)) => TokioListener::TcpTls(
-                TokioTcpListener::from_std(TcpListener::try_clone(listener).unwrap()).unwrap(),
+                TokioTcpListener::from_std(listener).unwrap(),
                 acceptor.clone(),
             ),
-            Listener::Unix(listener) => TokioListener::Unix(
-                TokioUnixListener::from_std(UnixListener::try_clone(listener).unwrap()).unwrap(),
-            ),
+            Listener::Unix(listener) => {
+                TokioListener::Unix(TokioUnixListener::from_std(listener).unwrap())
+            }
             Listener::UnixTls((listener, acceptor)) => TokioListener::UnixTls(
-                TokioUnixListener::from_std(UnixListener::try_clone(listener).unwrap()).unwrap(),
+                TokioUnixListener::from_std(listener).unwrap(),
                 acceptor.clone(),
             ),
         }

data/ext/itsi_server/src/server/process_worker.rs

@@ -53,8 +53,8 @@ impl ProcessWorker {
             }
             *self.child_pid.lock() = None;
         }
-
-        match call_with_gvl(|_ruby| fork(cluster_template.server.after_fork.lock().clone())) {
+        match call_with_gvl(|_ruby| fork(cluster_template.server.hooks.get("after_fork").cloned()))
+        {
             Some(pid) => {
                 *self.child_pid.lock() = Some(Pid::from_raw(pid));
             }
@@ -67,7 +67,7 @@ impl ProcessWorker {
                 }
                 match SingleMode::new(
                     cluster_template.server.clone(),
-                    cluster_template.listeners.clone(),
+                    cluster_template.listeners.lock().drain(..).collect(),
                     cluster_template.lifecycle_channel.clone(),
                 ) {
                     Ok(single_mode) => {
@@ -83,6 +83,13 @@ impl ProcessWorker {
         Ok(())
     }
 
+    pub fn pid(&self) -> i32 {
+        if let Some(pid) = *self.child_pid.lock() {
+            return pid.as_raw();
+        }
+        0
+    }
+
     pub(crate) fn memory_usage(&self) -> Option<u64> {
         if let Some(pid) = *self.child_pid.lock() {
             let s = System::new_all();

data/ext/itsi_server/src/server/serve_strategy/cluster_mode.rs

@@ -3,8 +3,11 @@ use crate::server::{
     process_worker::ProcessWorker,
 };
 use itsi_error::{ItsiError, Result};
-use itsi_rb_helpers::{call_without_gvl, create_ruby_thread};
+use itsi_rb_helpers::{
+    call_proc_and_log_errors, call_with_gvl, call_without_gvl, create_ruby_thread,
+};
 use itsi_tracing::{error, info, warn};
+use magnus::Value;
 use nix::{
     libc::{self, exit},
     unistd::Pid,
@@ -19,9 +22,9 @@ use tokio::{
     sync::{broadcast, watch, Mutex},
     time::{self, sleep},
 };
-use tracing::instrument;
+use tracing::{debug, instrument};
 pub(crate) struct ClusterMode {
-    pub listeners: Arc<Vec<Arc<Listener>>>,
+    pub listeners: parking_lot::Mutex<Vec<Listener>>,
     pub server: Arc<Server>,
     pub process_workers: parking_lot::Mutex<Vec<ProcessWorker>>,
     pub lifecycle_channel: broadcast::Sender<LifecycleEvent>,
@@ -34,12 +37,9 @@ static CHILD_SIGNAL_SENDER: parking_lot::Mutex<Option<watch::Sender<()>>> =
 impl ClusterMode {
     pub fn new(
         server: Arc<Server>,
-        listeners: Arc<Vec<Arc<Listener>>>,
+        listeners: Vec<Listener>,
         lifecycle_channel: broadcast::Sender<LifecycleEvent>,
     ) -> Self {
-        if let Some(f) = server.before_fork.lock().take() {
-            f();
-        }
         let process_workers = (0..server.workers)
             .map(|_| ProcessWorker {
                 worker_id: WORKER_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
@@ -48,7 +48,7 @@ impl ClusterMode {
             .collect();
 
         Self {
-            listeners,
+            listeners: parking_lot::Mutex::new(listeners),
             server,
             process_workers: parking_lot::Mutex::new(process_workers),
             lifecycle_channel,
@@ -152,7 +152,7 @@ impl ClusterMode {
 
         tokio::select! {
             _ = monitor_handle => {
-              info!("All children exited early, exit normally")
+              debug!("All children exited early, exit normally")
             }
             _ = sleep(Duration::from_secs_f64(shutdown_timeout)) => {
                 warn!("Graceful shutdown timeout reached, force killing remaining children");
@@ -191,6 +191,9 @@ impl ClusterMode {
     #[instrument(skip(self), fields(mode = "cluster", pid=format!("{:?}", Pid::this())))]
     pub fn run(self: Arc<Self>) -> Result<()> {
         info!("Starting in Cluster mode");
+        if let Some(proc) = self.server.hooks.get("before_fork") {
+            call_with_gvl(|_| call_proc_and_log_errors(proc.clone()))
+        }
         self.process_workers
             .lock()
             .iter()
@@ -228,6 +231,9 @@ impl ClusterMode {
                     if let Some(current_mem_usage) = largest_worker.memory_usage(){
                       if current_mem_usage > memory_limit {
                         largest_worker.reboot(self_ref.clone()).await.ok();
+                        if let Some(hook) = self_ref.server.hooks.get("after_memory_threshold_reached") {
+                          call_with_gvl(|_|  hook.call::<_, Value>((largest_worker.pid(),)).ok() );
+                        }
                       }
                     }
                   }

data/ext/itsi_server/src/server/serve_strategy/single_mode.rs

@@ -15,10 +15,13 @@ use hyper_util::{
     server::conn::auto::Builder,
 };
 use itsi_error::{ItsiError, Result};
+use itsi_rb_helpers::print_rb_backtrace;
 use itsi_tracing::{debug, error, info};
 use nix::unistd::Pid;
+use parking_lot::Mutex;
 use std::{
     num::NonZeroU8,
+    panic,
     pin::Pin,
     sync::Arc,
     time::{Duration, Instant},
@@ -37,7 +40,7 @@ pub struct SingleMode {
     pub executor: Builder<TokioExecutor>,
     pub server: Arc<Server>,
     pub sender: async_channel::Sender<RequestJob>,
-    pub(crate) listeners: Arc<Vec<Arc<Listener>>>,
+    pub(crate) listeners: Mutex<Vec<Listener>>,
     pub(crate) thread_workers: Arc<Vec<ThreadWorker>>,
     pub(crate) lifecycle_channel: broadcast::Sender<LifecycleEvent>,
 }
@@ -52,18 +55,24 @@ impl SingleMode {
     #[instrument(parent=None, skip_all, fields(pid=format!("{:?}", Pid::this())))]
     pub(crate) fn new(
         server: Arc<Server>,
-        listeners: Arc<Vec<Arc<Listener>>>,
+        listeners: Vec<Listener>,
         lifecycle_channel: broadcast::Sender<LifecycleEvent>,
     ) -> Result<Self> {
         let (thread_workers, sender) = build_thread_workers(
+            server.clone(),
             Pid::this(),
             NonZeroU8::try_from(server.threads).unwrap(),
             server.app.clone(),
             server.scheduler_class.clone(),
-        )?;
+        )
+        .inspect_err(|e| {
+            if let Some(err_val) = e.value() {
+                print_rb_backtrace(err_val);
+            }
+        })?;
         Ok(Self {
             executor: Builder::new(TokioExecutor::new()),
-            listeners,
+            listeners: Mutex::new(listeners),
             server,
             sender,
             thread_workers,
@@ -83,82 +92,81 @@ impl SingleMode {
     }
 
     pub fn stop(&self) -> Result<()> {
-        self.lifecycle_channel
-            .send(LifecycleEvent::Shutdown)
-            .expect("Failed to send shutdown event");
+        self.lifecycle_channel.send(LifecycleEvent::Shutdown).ok();
         Ok(())
     }
 
     #[instrument(parent=None, skip(self), fields(pid=format!("{}", Pid::this())))]
     pub fn run(self: Arc<Self>) -> Result<()> {
         let mut listener_task_set = JoinSet::new();
-        let self_ref = Arc::new(self);
-        let runtime = self_ref.build_runtime();
+        let runtime = self.build_runtime();
 
         runtime.block_on(async {
-          let tokio_listeners = self_ref
-              .listeners
-              .iter()
-              .map(|list| Arc::new(list.to_tokio_listener()))
-              .collect::<Vec<_>>();
-          let (shutdown_sender, _) = watch::channel::<RunningPhase>(RunningPhase::Running);
-          for listener in tokio_listeners.iter() {
-              let mut lifecycle_rx = self_ref.lifecycle_channel.subscribe();
-              let listener_info = Arc::new(listener.listener_info());
-              let self_ref = self_ref.clone();
-              let listener = listener.clone();
-              let shutdown_sender = shutdown_sender.clone();
-
+              let tokio_listeners = self
+                  .listeners.lock()
+                  .drain(..)
+                  .map(|list| {
+                    Arc::new(list.into_tokio_listener())
+                  })
+                  .collect::<Vec<_>>();
+              let (shutdown_sender, _) = watch::channel(RunningPhase::Running);
+              for listener in tokio_listeners.iter() {
+                  let mut lifecycle_rx = self.lifecycle_channel.subscribe();
+                  let listener_info = Arc::new(listener.listener_info());
+                  let self_ref = self.clone();
+                  let listener = listener.clone();
+                  let shutdown_sender = shutdown_sender.clone();
 
-              let listener_clone = listener.clone();
-              let mut shutdown_receiver = shutdown_sender.clone().subscribe();
-              let shutdown_receiver_clone = shutdown_receiver.clone();
-              listener_task_set.spawn(async move {
-                listener_clone.spawn_state_task(shutdown_receiver_clone).await;
-              });
+                  let listener_clone = listener.clone();
+                  let mut shutdown_receiver = shutdown_sender.subscribe();
+                  let shutdown_receiver_clone = shutdown_receiver.clone();
+                  listener_task_set.spawn(async move {
+                    listener_clone.spawn_state_task(shutdown_receiver_clone).await;
+                  });
 
-              listener_task_set.spawn(async move {
-                let strategy = self_ref.clone();
-                loop {
-                    tokio::select! {
-                        accept_result = listener.accept() => match accept_result {
-                          Ok(accept_result) => {
-                            match strategy.serve_connection(accept_result, listener_info.clone(), shutdown_receiver.clone()).await {
-                              Ok(_) => {
-                                debug!("Connection accepted and served");
+                  listener_task_set.spawn(async move {
+                    let strategy_clone = self_ref.clone();
+                    let mut acceptor_task_set = JoinSet::new();
+                    loop {
+                        tokio::select! {
+                            accept_result = listener.accept() => match accept_result {
+                              Ok(accept_result) => {
+                                let strategy = strategy_clone.clone();
+                                let listener_info = listener_info.clone();
+                                let shutdown_receiver = shutdown_receiver.clone();
+                                acceptor_task_set.spawn(async move {
+                                  strategy.serve_connection(accept_result, listener_info, shutdown_receiver).await;
+                                });
                               },
-                              Err(e) => error!("Error in serve_connection {:?}", e)
-                            }
-                          },
-                          Err(e) => debug!("Listener.accept failed {:?}", e),
-                        },
-                        _ = shutdown_receiver.changed() => {
-                          break;
-                        }
-                        lifecycle_event = lifecycle_rx.recv() => match lifecycle_event{
-                          Ok(lifecycle_event) => {
-                            if let Err(e) = strategy.handle_lifecycle_event(lifecycle_event, shutdown_sender.clone()).await{
-                              match e {
-                                ItsiError::Break() => break,
-                                _ => error!("Error in handle_lifecycle_event {:?}", e)
-                              }
+                              Err(e) => debug!("Listener.accept failed {:?}", e),
+                            },
+                            _ = shutdown_receiver.changed() => {
+                              break;
                             }
+                            lifecycle_event = lifecycle_rx.recv() => match lifecycle_event{
+                              Ok(lifecycle_event) => {
+                                if let Err(e) = self_ref.handle_lifecycle_event(lifecycle_event, shutdown_sender.clone()).await{
+                                  match e {
+                                    ItsiError::Break() => break,
+                                    _ => error!("Error in handle_lifecycle_event {:?}", e)
+                                  }
+                                }
 
-                          },
-                          Err(e) => error!("Error receiving lifecycle_event: {:?}", e),
-                      }
+                              },
+                              Err(e) => error!("Error receiving lifecycle_event: {:?}", e),
+                          }
+                        }
                     }
-                }
-            });
+                    while let Some(_res) = acceptor_task_set.join_next().await {}
+                });
 
-          }
+              }
 
-          while let Some(_res) = listener_task_set.join_next().await {}
+              while let Some(_res) = listener_task_set.join_next().await {}
 
-        });
+            });
         runtime.shutdown_timeout(Duration::from_millis(100));
-
-        info!("Runtime has shut down");
+        debug!("Runtime has shut down");
         Ok(())
     }
 
@@ -167,62 +175,60 @@ impl SingleMode {
         stream: IoStream,
         listener: Arc<ListenerInfo>,
         shutdown_channel: watch::Receiver<RunningPhase>,
-    ) -> Result<()> {
+    ) {
         let sender_clone = self.sender.clone();
         let addr = stream.addr();
         let io: TokioIo<Pin<Box<IoStream>>> = TokioIo::new(Box::pin(stream));
         let server = self.server.clone();
         let executor = self.executor.clone();
         let mut shutdown_channel_clone = shutdown_channel.clone();
-        tokio::spawn(async move {
-            let server = server.clone();
-            let mut executor = executor.clone();
-            let mut binding = executor.http1();
-            let shutdown_channel = shutdown_channel_clone.clone();
-            let mut serve = Box::pin(
-                binding
-                    .timer(TokioTimer::new())
-                    .header_read_timeout(Duration::from_secs(1))
-                    .serve_connection_with_upgrades(
-                        io,
-                        service_fn(move |hyper_request: Request<Incoming>| {
-                            ItsiRequest::process_request(
-                                hyper_request,
-                                sender_clone.clone(),
-                                server.clone(),
-                                listener.clone(),
-                                addr.clone(),
-                                shutdown_channel.clone(),
-                            )
-                        }),
-                    ),
-            );
+        let server = server.clone();
+        let mut executor = executor.clone();
+        let mut binding = executor.http1();
+        let shutdown_channel = shutdown_channel_clone.clone();
+        let mut serve = Box::pin(
+            binding
+                .timer(TokioTimer::new())
+                .header_read_timeout(Duration::from_secs(1))
+                .serve_connection_with_upgrades(
+                    io,
+                    service_fn(move |hyper_request: Request<Incoming>| {
+                        ItsiRequest::process_request(
+                            hyper_request,
+                            sender_clone.clone(),
+                            server.clone(),
+                            listener.clone(),
+                            addr.clone(),
+                            shutdown_channel.clone(),
+                        )
+                    }),
+                ),
+        );
 
-            tokio::select! {
-                // Await the connection finishing naturally.
-                res = &mut serve => {
-                    match res{
-                        Ok(()) => {
-                          debug!("Connection closed normally")
-                        },
-                        Err(res) => {
-                          debug!("Connection finished with error: {:?}", res)
-                        }
-                    }
-                    serve.as_mut().graceful_shutdown();
-                },
-                // A lifecycle event triggers shutdown.
-                _ = shutdown_channel_clone.changed() => {
-                    // Initiate graceful shutdown.
-                    serve.as_mut().graceful_shutdown();
-                    // Now await the connection to finish shutting down.
-                    if let Err(e) = serve.await {
-                        debug!("Connection shutdown error: {:?}", e);
+        tokio::select! {
+            // Await the connection finishing naturally.
+            res = &mut serve => {
+                match res{
+                    Ok(()) => {
+                      debug!("Connection closed normally")
+                    },
+                    Err(res) => {
+                      debug!("Connection finished with error: {:?}", res)
                     }
                 }
+                serve.as_mut().graceful_shutdown();
+            },
+            // A lifecycle event triggers shutdown.
+            _ = shutdown_channel_clone.changed() => {
+                // Initiate graceful shutdown.
+                serve.as_mut().graceful_shutdown();
+
+                // Now await the connection to finish shutting down.
+                if let Err(e) = serve.await {
+                    debug!("Connection shutdown error: {:?}", e);
+                }
             }
-        });
-        Ok(())
+        }
     }
 
     pub async fn handle_lifecycle_event(
@@ -232,13 +238,20 @@ impl SingleMode {
     ) -> Result<()> {
         info!("Handling lifecycle event: {:?}", lifecycle_event);
         if let LifecycleEvent::Shutdown = lifecycle_event {
+            //1. Stop accepting new connections.
             shutdown_sender.send(RunningPhase::ShutdownPending).ok();
-            let deadline = Instant::now() + Duration::from_secs_f64(self.server.shutdown_timeout);
+            tokio::time::sleep(Duration::from_millis(25)).await;
+
+            //2. Break out of work queues.
             for worker in &*self.thread_workers {
                 worker.request_shutdown().await;
             }
+
+            tokio::time::sleep(Duration::from_millis(25)).await;
+
+            //3. Wait for all threads to finish.
+            let deadline = Instant::now() + Duration::from_secs_f64(self.server.shutdown_timeout);
             while Instant::now() < deadline {
-                tokio::time::sleep(Duration::from_millis(50)).await;
                 let alive_threads = self
                     .thread_workers
                     .iter()
@@ -250,7 +263,7 @@ impl SingleMode {
                 tokio::time::sleep(Duration::from_millis(200)).await;
             }
 
-            info!("Sending shutdown signal");
+            //4. Force shutdown any stragglers
             shutdown_sender.send(RunningPhase::Shutdown).ok();
             self.thread_workers.iter().for_each(|worker| {
                 worker.poll_shutdown(deadline);

data/ext/itsi_server/src/server/signal.rs

@@ -11,10 +11,7 @@ pub static SIGNAL_HANDLER_CHANNEL: LazyLock<(
 )> = LazyLock::new(|| sync::broadcast::channel(5));
 
 pub fn send_shutdown_event() {
-    SIGNAL_HANDLER_CHANNEL
-        .0
-        .send(LifecycleEvent::Shutdown)
-        .expect("Failed to send shutdown event");
+    SIGNAL_HANDLER_CHANNEL.0.send(LifecycleEvent::Shutdown).ok();
 }
 
 pub static SIGINT_COUNT: AtomicI8 = AtomicI8::new(0);

data/ext/itsi_server/src/server/thread_worker.rs

@@ -1,4 +1,4 @@
-use super::itsi_server::RequestJob;
+use super::itsi_server::{RequestJob, Server};
 use crate::{request::itsi_request::ItsiRequest, ITSI_SERVER};
 use itsi_rb_helpers::{
     call_with_gvl, call_without_gvl, create_ruby_thread, kill_threads, HeapVal, HeapValue,
@@ -24,6 +24,7 @@ use std::{
 use tokio::{runtime::Builder as RuntimeBuilder, sync::watch};
 use tracing::instrument;
 pub struct ThreadWorker {
+    pub server: Arc<Server>,
     pub id: String,
     pub app: Opaque<Value>,
     pub receiver: Arc<async_channel::Receiver<RequestJob>>,
@@ -48,8 +49,9 @@ static CLASS_FIBER: Lazy<RClass> = Lazy::new(|ruby| {
 
 pub struct TerminateWakerSignal(bool);
 
-#[instrument(name = "Boot", parent=None, skip(threads, app, pid, scheduler_class))]
+#[instrument(name = "Boot", parent=None, skip(server, threads, app, pid, scheduler_class))]
 pub fn build_thread_workers(
+    server: Arc<Server>,
     pid: Pid,
     threads: NonZeroU8,
     app: HeapVal,
@@ -65,6 +67,7 @@ pub fn build_thread_workers(
                 .map(|id| {
                     info!(pid = pid.as_raw(), id, "Thread");
                     ThreadWorker::new(
+                        server.clone(),
                         format!("{:?}#{:?}", pid, id),
                         app,
                         receiver_ref.clone(),
@@ -83,10 +86,7 @@ pub fn load_app(
     scheduler_class: Option<String>,
 ) -> Result<(Opaque<Value>, Option<Opaque<Value>>)> {
     call_with_gvl(|ruby| {
-        let app = Opaque::from(
-            app.funcall::<_, _, Value>(*ID_CALL, ())
-                .expect("Couldn't load app"),
-        );
+        let app = Opaque::from(app.funcall::<_, _, Value>(*ID_CALL, ())?);
         let scheduler_class = if let Some(scheduler_class) = scheduler_class {
             Some(Opaque::from(
                 ruby.module_kernel()
@@ -100,6 +100,7 @@ pub fn load_app(
 }
 impl ThreadWorker {
     pub fn new(
+        server: Arc<Server>,
         id: String,
         app: Opaque<Value>,
         receiver: Arc<async_channel::Receiver<RequestJob>>,
@@ -107,6 +108,7 @@ impl ThreadWorker {
         scheduler_class: Option<Opaque<Value>>,
     ) -> Result<Self> {
         let mut worker = Self {
+            server,
             id,
             app,
             receiver,
@@ -125,7 +127,7 @@ impl ThreadWorker {
             Ok(_) => {}
             Err(err) => error!("Failed to send shutdown request: {}", err),
         };
-        info!("Requesting shutdown");
+        debug!("Requesting shutdown");
     }
 
     #[instrument(skip(self, deadline), fields(id = self.id))]
@@ -140,7 +142,7 @@ impl ThreadWorker {
                 if thread.funcall::<_, _, bool>(*ID_ALIVE, ()).unwrap_or(false) {
                     return true;
                 }
-                info!("Thread has shut down");
+                debug!("Thread has shut down");
             }
             self.thread.write().take();
 
@@ -154,17 +156,23 @@ impl ThreadWorker {
         let receiver = self.receiver.clone();
         let terminated = self.terminated.clone();
         let scheduler_class = self.scheduler_class;
+        let server = self.server.clone();
         call_with_gvl(|_| {
             *self.thread.write() = Some(
                 create_ruby_thread(move || {
                     if let Some(scheduler_class) = scheduler_class {
-                        if let Err(err) =
-                            Self::fiber_accept_loop(id, app, receiver, scheduler_class, terminated)
-                        {
+                        if let Err(err) = Self::fiber_accept_loop(
+                            server,
+                            id,
+                            app,
+                            receiver,
+                            scheduler_class,
+                            terminated,
+                        ) {
                             error!("Error in fiber_accept_loop: {:?}", err);
                         }
                     } else {
-                        Self::accept_loop(id, app, receiver, terminated);
+                        Self::accept_loop(server, id, app, receiver, terminated);
                     }
                 })
                 .into(),
@@ -180,6 +188,7 @@ impl ThreadWorker {
         receiver: &Arc<async_channel::Receiver<RequestJob>>,
         terminated: &Arc<AtomicBool>,
         waker_sender: &watch::Sender<TerminateWakerSignal>,
+        oob_gc_responses_threshold: Option<u64>,
     ) -> magnus::block::Proc {
         let leader = leader.clone();
         let receiver = receiver.clone();
@@ -243,10 +252,15 @@ impl ThreadWorker {
                 }
 
                 let yield_result = if receiver.is_empty() {
+                    let should_gc = if let Some(oob_gc_threshold) = oob_gc_responses_threshold {
+                        idle_counter = (idle_counter + 1) % oob_gc_threshold;
+                        idle_counter == 0
+                    } else {
+                        false
+                    };
                     waker_sender.send(TerminateWakerSignal(false)).unwrap();
-                    idle_counter = (idle_counter + 1) % 100;
                     call_with_gvl(|ruby| {
-                        if idle_counter == 0 {
+                        if should_gc {
                             ruby.gc_start();
                         }
                         scheduler.funcall::<_, _, Value>(*ID_BLOCK, (thread_current, None::<u8>))
@@ -264,6 +278,8 @@ impl ThreadWorker {
 
     #[instrument(skip_all, fields(thread_worker=id))]
     pub fn fiber_accept_loop(
+        server: Arc<Server>,
+
         id: String,
         app: Opaque<Value>,
         receiver: Arc<async_channel::Receiver<RequestJob>>,
@@ -273,10 +289,16 @@ impl ThreadWorker {
         let ruby = Ruby::get().unwrap();
         let (waker_sender, waker_receiver) = watch::channel(TerminateWakerSignal(false));
         let leader: Arc<Mutex<Option<RequestJob>>> = Arc::new(Mutex::new(None));
-        let server = ruby.get_inner(&ITSI_SERVER);
-        let scheduler_proc =
-            Self::build_scheduler_proc(app, &leader, &receiver, &terminated, &waker_sender);
-        let (scheduler, scheduler_fiber) = server.funcall::<_, _, (Value, Value)>(
+        let server_class = ruby.get_inner(&ITSI_SERVER);
+        let scheduler_proc = Self::build_scheduler_proc(
+            app,
+            &leader,
+            &receiver,
+            &terminated,
+            &waker_sender,
+            server.oob_gc_responses_threshold,
+        );
+        let (scheduler, scheduler_fiber) = server_class.funcall::<_, _, (Value, Value)>(
             "start_scheduler_loop",
             (scheduler_class, scheduler_proc),
         )?;
@@ -337,21 +359,31 @@ impl ThreadWorker {
 
     #[instrument(skip_all, fields(thread_worker=id))]
     pub fn accept_loop(
+        server: Arc<Server>,
         id: String,
         app: Opaque<Value>,
         receiver: Arc<async_channel::Receiver<RequestJob>>,
         terminated: Arc<AtomicBool>,
     ) {
         let ruby = Ruby::get().unwrap();
-        let server = ruby.get_inner(&ITSI_SERVER);
+        let server_class = ruby.get_inner(&ITSI_SERVER);
+        let mut idle_counter = 0;
         call_without_gvl(|| loop {
+            if receiver.is_empty() {
+                if let Some(oob_gc_threshold) = server.oob_gc_responses_threshold {
+                    idle_counter = (idle_counter + 1) % oob_gc_threshold;
+                    if idle_counter == 0 {
+                        ruby.gc_start();
+                    }
+                };
+            }
             match receiver.recv_blocking() {
                 Ok(RequestJob::ProcessRequest(request)) => {
                     if terminated.load(Ordering::Relaxed) {
                         break;
                     }
                     call_with_gvl(|_ruby| {
-                        request.process(&ruby, server, app).ok();
+                        request.process(&ruby, server_class, app).ok();
                     })
                 }
                 Ok(RequestJob::Shutdown) => {

data/ext/itsi_server/src/server/tls.rs

@@ -63,7 +63,7 @@ pub fn configure_tls(
                 .map(|s| s.to_string())
                 .or_else(|| (*ITSI_ACME_CONTACT_EMAIL).as_ref().ok().map(|s| s.to_string()))
                 .ok_or_else(|| itsi_error::ItsiError::ArgumentError(
-                    "acme_cert query param or ITSI_ACME_CONTACT_EMAIL must be set before you can auto-generate let's encrypt certificates".to_string(),
+                    "acme_email query param or ITSI_ACME_CONTACT_EMAIL must be set before you can auto-generate let's encrypt certificates".to_string(),
                 ))?;
 
             let acme_config = AcmeConfig::new(domains)

data/lib/itsi/scheduler/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Scheduler
-    VERSION = "0.1.9"
+    VERSION = "0.1.11"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: itsi-scheduler
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.11
 platform: ruby
 authors:
 - Wouter Coppieters
 bindir: exe
 cert_chain: []
-date: 2025-03-16 00:00:00.000000000 Z
+date: 2025-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys