itsi-scheduler 0.1.5 → 0.1.19

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

@@ -1,59 +1,63 @@
-use std::sync::{atomic::AtomicI8, LazyLock};
+use std::sync::{
+    atomic::{AtomicBool, AtomicI8},
+    LazyLock,
+};
 
 use nix::libc::{self, sighandler_t};
 use tokio::sync::{self, broadcast};
 
 use super::lifecycle_event::LifecycleEvent;
 
+pub static SIGINT_COUNT: AtomicI8 = AtomicI8::new(0);
+pub static SHUTDOWN_REQUESTED: AtomicBool = AtomicBool::new(false);
 pub static SIGNAL_HANDLER_CHANNEL: LazyLock<(
     broadcast::Sender<LifecycleEvent>,
     broadcast::Receiver<LifecycleEvent>,
 )> = LazyLock::new(|| sync::broadcast::channel(5));
 
-pub static SIGINT_COUNT: AtomicI8 = AtomicI8::new(0);
+pub fn send_lifecycle_event(event: LifecycleEvent) {
+    SIGNAL_HANDLER_CHANNEL.0.send(event).ok();
+}
+
 fn receive_signal(signum: i32, _: sighandler_t) {
     SIGINT_COUNT.fetch_add(-1, std::sync::atomic::Ordering::SeqCst);
-    match signum {
+    let event = match signum {
         libc::SIGTERM | libc::SIGINT => {
+            SHUTDOWN_REQUESTED.store(true, std::sync::atomic::Ordering::SeqCst);
             SIGINT_COUNT.fetch_add(2, std::sync::atomic::Ordering::SeqCst);
             if SIGINT_COUNT.load(std::sync::atomic::Ordering::SeqCst) < 2 {
-                SIGNAL_HANDLER_CHANNEL.0.send(LifecycleEvent::Shutdown).ok();
+                Some(LifecycleEvent::Shutdown)
             } else {
                 // Not messing about. Force shutdown.
-                SIGNAL_HANDLER_CHANNEL
-                    .0
-                    .send(LifecycleEvent::ForceShutdown)
-                    .ok();
+                Some(LifecycleEvent::ForceShutdown)
             }
         }
-        libc::SIGUSR1 => {
-            SIGNAL_HANDLER_CHANNEL.0.send(LifecycleEvent::Restart).ok();
-        }
-        libc::SIGTTIN => {
-            SIGNAL_HANDLER_CHANNEL
-                .0
-                .send(LifecycleEvent::IncreaseWorkers)
-                .ok();
-        }
-        libc::SIGTTOU => {
-            SIGNAL_HANDLER_CHANNEL
-                .0
-                .send(LifecycleEvent::DecreaseWorkers)
-                .ok();
-        }
-        _ => {}
+        libc::SIGUSR2 => Some(LifecycleEvent::PrintInfo),
+        libc::SIGUSR1 => Some(LifecycleEvent::Restart),
+        libc::SIGHUP => Some(LifecycleEvent::Reload),
+        libc::SIGTTIN => Some(LifecycleEvent::IncreaseWorkers),
+        libc::SIGTTOU => Some(LifecycleEvent::DecreaseWorkers),
+        libc::SIGCHLD => Some(LifecycleEvent::ChildTerminated),
+        _ => None,
+    };
+
+    if let Some(event) = event {
+        send_lifecycle_event(event);
     }
 }
 
 pub fn reset_signal_handlers() -> bool {
     SIGINT_COUNT.store(0, std::sync::atomic::Ordering::SeqCst);
+    SHUTDOWN_REQUESTED.store(false, std::sync::atomic::Ordering::SeqCst);
     unsafe {
         libc::signal(libc::SIGTERM, receive_signal as usize);
         libc::signal(libc::SIGINT, receive_signal as usize);
-        libc::signal(libc::SIGUSR1, receive_signal as usize);
         libc::signal(libc::SIGUSR2, receive_signal as usize);
+        libc::signal(libc::SIGUSR1, receive_signal as usize);
+        libc::signal(libc::SIGHUP, receive_signal as usize);
         libc::signal(libc::SIGTTIN, receive_signal as usize);
         libc::signal(libc::SIGTTOU, receive_signal as usize);
+        libc::signal(libc::SIGCHLD, receive_signal as usize);
     }
     true
 }
@@ -62,9 +66,11 @@ pub fn clear_signal_handlers() {
     unsafe {
         libc::signal(libc::SIGTERM, libc::SIG_DFL);
         libc::signal(libc::SIGINT, libc::SIG_DFL);
-        libc::signal(libc::SIGUSR1, libc::SIG_DFL);
         libc::signal(libc::SIGUSR2, libc::SIG_DFL);
+        libc::signal(libc::SIGUSR1, libc::SIG_DFL);
+        libc::signal(libc::SIGHUP, libc::SIG_DFL);
         libc::signal(libc::SIGTTIN, libc::SIG_DFL);
         libc::signal(libc::SIGTTOU, libc::SIG_DFL);
+        libc::signal(libc::SIGCHLD, libc::SIG_DFL);
     }
 }

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

@@ -0,0 +1,101 @@
+use bytes::Buf;
+use hyper::body::Body;
+use hyper::body::Frame;
+use hyper::body::SizeHint;
+use std::error::Error;
+use std::fmt;
+use std::ops::Deref;
+use std::pin::Pin;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+use std::task::Context;
+use std::task::Poll;
+
+/// Custom error to indicate that the maximum body size was exceeded.
+#[derive(Debug)]
+pub struct MaxBodySizeReached;
+impl fmt::Display for MaxBodySizeReached {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Maximum body size reached")
+    }
+}
+
+impl Error for MaxBodySizeReached {}
+
+#[derive(Debug)]
+pub struct SizeLimitedIncoming<B> {
+    pub inner: B,
+    pub limit: AtomicUsize,
+    current: usize,
+}
+
+impl<B> Deref for SizeLimitedIncoming<B> {
+    type Target = B;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<B> SizeLimitedIncoming<B> {
+    pub fn new(inner: B) -> Self {
+        Self {
+            inner,
+            limit: AtomicUsize::new(usize::MAX),
+            current: 0,
+        }
+    }
+}
+
+impl<B> Body for SizeLimitedIncoming<B>
+where
+    B: Body + Unpin,
+    B::Data: Buf,
+    // Ensure that the inner error converts into our boxed error type.
+    B::Error: Into<Box<dyn Error + Send + Sync>>,
+{
+    type Data = B::Data;
+    type Error = Box<dyn Error + Send + Sync>;
+
+    fn poll_frame(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {
+        // Pin the inner body.
+        let inner = Pin::new(&mut self.inner);
+        match inner.poll_frame(cx) {
+            Poll::Ready(Some(Ok(frame))) => {
+                // Use public methods since we cannot match on the private enum.
+                if frame.is_data() {
+                    match frame.into_data() {
+                        Ok(data) => {
+                            let len = data.remaining();
+                            self.current += len;
+                            if self.current > self.limit.load(Ordering::Relaxed) {
+                                Poll::Ready(Some(Err(Box::new(MaxBodySizeReached))))
+                            } else {
+                                Poll::Ready(Some(Ok(Frame::data(data))))
+                            }
+                        }
+                        // Should not occur if is_data() was true, but pass through if it does.
+                        Err(frame) => Poll::Ready(Some(Ok(frame))),
+                    }
+                } else {
+                    // For non-data frames (e.g. trailers), just pass them along.
+                    Poll::Ready(Some(Ok(frame)))
+                }
+            }
+            Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(e.into()))),
+            Poll::Ready(None) => Poll::Ready(None),
+            Poll::Pending => Poll::Pending,
+        }
+    }
+
+    fn is_end_stream(&self) -> bool {
+        self.inner.is_end_stream()
+    }
+
+    fn size_hint(&self) -> SizeHint {
+        self.inner.size_hint()
+    }
+}

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

@@ -1,9 +1,8 @@
-use super::itsi_server::RequestJob;
-use crate::{request::itsi_request::ItsiRequest, ITSI_SERVER};
+use async_channel::Sender;
 use itsi_rb_helpers::{
     call_with_gvl, call_without_gvl, create_ruby_thread, kill_threads, HeapValue,
 };
-use itsi_tracing::{debug, error, info, warn};
+use itsi_tracing::{debug, error, warn};
 use magnus::{
     error::Result,
     value::{InnerValue, Lazy, LazyId, Opaque, ReprValue},
@@ -12,28 +11,36 @@ use magnus::{
 use nix::unistd::Pid;
 use parking_lot::{Mutex, RwLock};
 use std::{
-    num::NonZeroU8,
     ops::Deref,
     sync::{
-        atomic::{AtomicBool, Ordering},
+        atomic::{AtomicBool, AtomicU64, Ordering},
         Arc,
     },
     thread,
-    time::{Duration, Instant},
+    time::{Duration, Instant, SystemTime, UNIX_EPOCH},
 };
 use tokio::{runtime::Builder as RuntimeBuilder, sync::watch};
 use tracing::instrument;
+
+use crate::ruby_types::{
+    itsi_grpc_call::ItsiGrpcCall, itsi_http_request::ItsiHttpRequest,
+    itsi_server::itsi_server_config::ServerParams, ITSI_SERVER,
+};
+
+use super::request_job::RequestJob;
 pub struct ThreadWorker {
-    pub id: String,
-    pub app: Opaque<Value>,
+    pub params: Arc<ServerParams>,
+    pub id: u8,
+    pub name: String,
+    pub request_id: AtomicU64,
+    pub current_request_start: AtomicU64,
     pub receiver: Arc<async_channel::Receiver<RequestJob>>,
-    pub sender: async_channel::Sender<RequestJob>,
+    pub sender: Sender<RequestJob>,
     pub thread: RwLock<Option<HeapValue<Thread>>>,
     pub terminated: Arc<AtomicBool>,
     pub scheduler_class: Option<Opaque<Value>>,
 }
 
-static ID_CALL: LazyId = LazyId::new("call");
 static ID_ALIVE: LazyId = LazyId::new("alive?");
 static ID_SCHEDULER: LazyId = LazyId::new("scheduler");
 static ID_SCHEDULE: LazyId = LazyId::new("schedule");
@@ -47,47 +54,71 @@ static CLASS_FIBER: Lazy<RClass> = Lazy::new(|ruby| {
 });
 
 pub struct TerminateWakerSignal(bool);
+type ThreadWorkerBuildResult = Result<(
+    Arc<Vec<Arc<ThreadWorker>>>,
+    Sender<RequestJob>,
+    Sender<RequestJob>,
+)>;
+
+#[instrument(name = "boot", parent=None, skip(params, pid))]
+pub fn build_thread_workers(params: Arc<ServerParams>, pid: Pid) -> ThreadWorkerBuildResult {
+    let blocking_thread_count = params.threads;
+    let nonblocking_thread_count = params.scheduler_threads;
+
+    let (blocking_sender, blocking_receiver) =
+        async_channel::bounded((blocking_thread_count as u16 * 30) as usize);
+    let blocking_receiver_ref = Arc::new(blocking_receiver);
+    let blocking_sender_ref = blocking_sender;
+    let scheduler_class = load_scheduler_class(params.scheduler_class.clone())?;
+
+    let mut workers = (1..=blocking_thread_count)
+        .map(|id| {
+            ThreadWorker::new(
+                params.clone(),
+                id,
+                format!("{:?}#{:?}", pid, id),
+                blocking_receiver_ref.clone(),
+                blocking_sender_ref.clone(),
+                if nonblocking_thread_count.is_some() {
+                    None
+                } else {
+                    scheduler_class
+                },
+            )
+        })
+        .collect::<Result<Vec<_>>>()?;
+
+    let nonblocking_sender_ref = if let (Some(nonblocking_thread_count), Some(scheduler_class)) =
+        (nonblocking_thread_count, scheduler_class)
+    {
+        let (nonblocking_sender, nonblocking_receiver) =
+            async_channel::bounded((nonblocking_thread_count as u16 * 30) as usize);
+        let nonblocking_receiver_ref = Arc::new(nonblocking_receiver);
+        let nonblocking_sender_ref = nonblocking_sender.clone();
+        for id in 0..nonblocking_thread_count {
+            workers.push(ThreadWorker::new(
+                params.clone(),
+                id,
+                format!("{:?}#{:?}", pid, id),
+                nonblocking_receiver_ref.clone(),
+                nonblocking_sender_ref.clone(),
+                Some(scheduler_class),
+            )?)
+        }
+        nonblocking_sender
+    } else {
+        blocking_sender_ref.clone()
+    };
 
-#[instrument(name = "Boot", parent=None, skip(threads, app, pid, scheduler_class))]
-pub fn build_thread_workers(
-    pid: Pid,
-    threads: NonZeroU8,
-    app: Opaque<Value>,
-    scheduler_class: Option<String>,
-) -> Result<(Arc<Vec<ThreadWorker>>, async_channel::Sender<RequestJob>)> {
-    let (sender, receiver) = async_channel::bounded(20);
-    let receiver_ref = Arc::new(receiver);
-    let sender_ref = sender;
-    let (app, scheduler_class) = load_app(app, scheduler_class)?;
     Ok((
-        Arc::new(
-            (1..=u8::from(threads))
-                .map(|id| {
-                    info!(pid = pid.as_raw(), id, "Thread");
-                    ThreadWorker::new(
-                        format!("{:?}#{:?}", pid, id),
-                        app,
-                        receiver_ref.clone(),
-                        sender_ref.clone(),
-                        scheduler_class,
-                    )
-                })
-                .collect::<Result<Vec<_>>>()?,
-        ),
-        sender_ref,
+        Arc::new(workers),
+        blocking_sender_ref,
+        nonblocking_sender_ref,
     ))
 }
 
-pub fn load_app(
-    app: Opaque<Value>,
-    scheduler_class: Option<String>,
-) -> Result<(Opaque<Value>, Option<Opaque<Value>>)> {
+pub fn load_scheduler_class(scheduler_class: Option<String>) -> Result<Option<Opaque<Value>>> {
     call_with_gvl(|ruby| {
-        let app = app.get_inner_with(&ruby);
-        let app = Opaque::from(
-            app.funcall::<_, _, Value>(*ID_CALL, ())
-                .expect("Couldn't load app"),
-        );
         let scheduler_class = if let Some(scheduler_class) = scheduler_class {
             Some(Opaque::from(
                 ruby.module_kernel()
@@ -96,76 +127,75 @@ pub fn load_app(
         } else {
             None
         };
-        Ok((app, scheduler_class))
+        Ok(scheduler_class)
     })
 }
 impl ThreadWorker {
     pub fn new(
-        id: String,
-        app: Opaque<Value>,
+        params: Arc<ServerParams>,
+        id: u8,
+        name: String,
         receiver: Arc<async_channel::Receiver<RequestJob>>,
-        sender: async_channel::Sender<RequestJob>,
+        sender: Sender<RequestJob>,
         scheduler_class: Option<Opaque<Value>>,
-    ) -> Result<Self> {
-        let mut worker = Self {
+    ) -> Result<Arc<Self>> {
+        let worker = Arc::new(Self {
+            params,
             id,
-            app,
+            request_id: AtomicU64::new(0),
+            current_request_start: AtomicU64::new(0),
+            name,
             receiver,
             sender,
             thread: RwLock::new(None),
             terminated: Arc::new(AtomicBool::new(false)),
             scheduler_class,
-        };
-        worker.run()?;
+        });
+        worker.clone().run()?;
         Ok(worker)
     }
 
-    #[instrument(skip(self), fields(id = self.id))]
-    pub async fn request_shutdown(&self) {
-        match self.sender.send(RequestJob::Shutdown).await {
-            Ok(_) => {}
-            Err(err) => error!("Failed to send shutdown request: {}", err),
-        };
-        info!("Requesting shutdown");
-    }
-
     #[instrument(skip(self, deadline), fields(id = self.id))]
     pub fn poll_shutdown(&self, deadline: Instant) -> bool {
-        call_with_gvl(|_ruby| {
-            if let Some(thread) = self.thread.read().deref() {
-                if Instant::now() > deadline {
-                    warn!("Worker shutdown timed out. Killing thread");
-                    self.terminated.store(true, Ordering::SeqCst);
-                    kill_threads(vec![thread.as_value()]);
-                }
-                if thread.funcall::<_, _, bool>(*ID_ALIVE, ()).unwrap_or(false) {
-                    return true;
-                }
-                info!("Thread has shut down");
+        if let Some(thread) = self.thread.read().deref() {
+            if Instant::now() > deadline {
+                warn!("Worker shutdown timed out. Killing thread");
+                self.terminated.store(true, Ordering::SeqCst);
+                kill_threads(vec![thread.as_value()]);
             }
-            self.thread.write().take();
+            debug!("Checking thread status");
+            if thread.funcall::<_, _, bool>(*ID_ALIVE, ()).unwrap_or(false) {
+                return true;
+            }
+            debug!("Thread has shut down");
+        }
+        self.thread.write().take();
 
-            false
-        })
+        false
     }
 
-    pub fn run(&mut self) -> Result<()> {
-        let id = self.id.clone();
-        let app = self.app;
+    pub fn run(self: Arc<Self>) -> Result<()> {
+        let name = self.name.clone();
         let receiver = self.receiver.clone();
         let terminated = self.terminated.clone();
         let scheduler_class = self.scheduler_class;
+        let params = self.params.clone();
+        let self_ref = self.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_ref.fiber_accept_loop(
+                            params,
+                            name,
+                            receiver,
+                            scheduler_class,
+                            terminated,
+                        ) {
                             error!("Error in fiber_accept_loop: {:?}", err);
                         }
                     } else {
-                        Self::accept_loop(id, app, receiver, terminated);
+                        self_ref.accept_loop(params, name, receiver, terminated);
                     }
                 })
                 .into(),
@@ -176,11 +206,12 @@ impl ThreadWorker {
     }
 
     pub fn build_scheduler_proc(
-        app: Opaque<Value>,
+        self: Arc<Self>,
         leader: &Arc<Mutex<Option<RequestJob>>>,
         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();
@@ -197,6 +228,7 @@ impl ThreadWorker {
             let receiver = receiver.clone();
             let terminated = terminated.clone();
             let waker_sender = waker_sender.clone();
+            let self_ref = self.clone();
             let mut batch = Vec::with_capacity(MAX_BATCH_SIZE as usize);
 
             static MAX_BATCH_SIZE: i32 = 25;
@@ -204,8 +236,11 @@ impl ThreadWorker {
                 let mut idle_counter = 0;
                 if let Some(v) = leader_clone.lock().take() {
                     match v {
-                        RequestJob::ProcessRequest(itsi_request) => {
-                            batch.push(RequestJob::ProcessRequest(itsi_request))
+                        RequestJob::ProcessHttpRequest(itsi_request, app_proc) => {
+                            batch.push(RequestJob::ProcessHttpRequest(itsi_request, app_proc))
+                        }
+                        RequestJob::ProcessGrpcRequest(itsi_request, app_proc) => {
+                            batch.push(RequestJob::ProcessGrpcRequest(itsi_request, app_proc))
                         }
                         RequestJob::Shutdown => {
                             waker_sender.send(TerminateWakerSignal(true)).unwrap();
@@ -224,12 +259,38 @@ impl ThreadWorker {
                 let shutdown_requested = call_with_gvl(|_| {
                     for req in batch.drain(..) {
                         match req {
-                            RequestJob::ProcessRequest(request) => {
+                            RequestJob::ProcessHttpRequest(request, app_proc) => {
+                                self_ref.request_id.fetch_add(1, Ordering::Relaxed);
+                                self_ref.current_request_start.store(
+                                    SystemTime::now()
+                                        .duration_since(UNIX_EPOCH)
+                                        .unwrap()
+                                        .as_secs(),
+                                    Ordering::Relaxed,
+                                );
                                 let response = request.response.clone();
-                                if let Err(err) =
-                                    server.funcall::<_, _, Value>(*ID_SCHEDULE, (app, request))
-                                {
-                                    ItsiRequest::internal_error(ruby, response, err)
+                                if let Err(err) = server.funcall::<_, _, Value>(
+                                    *ID_SCHEDULE,
+                                    (app_proc.as_value(), request),
+                                ) {
+                                    ItsiHttpRequest::internal_error(ruby, response, err)
+                                }
+                            }
+                            RequestJob::ProcessGrpcRequest(request, app_proc) => {
+                                self_ref.request_id.fetch_add(1, Ordering::Relaxed);
+                                self_ref.current_request_start.store(
+                                    SystemTime::now()
+                                        .duration_since(UNIX_EPOCH)
+                                        .unwrap()
+                                        .as_secs(),
+                                    Ordering::Relaxed,
+                                );
+                                let response = request.stream.clone();
+                                if let Err(err) = server.funcall::<_, _, Value>(
+                                    *ID_SCHEDULE,
+                                    (app_proc.as_value(), request),
+                                ) {
+                                    ItsiGrpcCall::internal_error(ruby, response, err)
                                 }
                             }
                             RequestJob::Shutdown => return true,
@@ -244,10 +305,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>))
@@ -263,10 +329,11 @@ impl ThreadWorker {
         })
     }
 
-    #[instrument(skip_all, fields(thread_worker=id))]
+    #[instrument(skip_all, fields(thread_worker=name))]
     pub fn fiber_accept_loop(
-        id: String,
-        app: Opaque<Value>,
+        self: Arc<Self>,
+        params: Arc<ServerParams>,
+        name: String,
         receiver: Arc<async_channel::Receiver<RequestJob>>,
         scheduler_class: Opaque<Value>,
         terminated: Arc<AtomicBool>,
@@ -274,10 +341,15 @@ 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(
+            &leader,
+            &receiver,
+            &terminated,
+            &waker_sender,
+            params.oob_gc_responses_threshold,
+        );
+        let (scheduler, scheduler_fiber) = server_class.funcall::<_, _, (Value, Value)>(
             "start_scheduler_loop",
             (scheduler_class, scheduler_proc),
         )?;
@@ -338,25 +410,60 @@ impl ThreadWorker {
 
     #[instrument(skip_all, fields(thread_worker=id))]
     pub fn accept_loop(
+        self: Arc<Self>,
+        params: Arc<ServerParams>,
         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 mut idle_counter = 0;
+        let self_ref = self.clone();
         call_without_gvl(|| loop {
+            if receiver.is_empty() {
+                if let Some(oob_gc_threshold) = params.oob_gc_responses_threshold {
+                    idle_counter = (idle_counter + 1) % oob_gc_threshold;
+                    if idle_counter == 0 {
+                        call_with_gvl(|_ruby| {
+                            ruby.gc_start();
+                        });
+                    }
+                };
+            }
             match receiver.recv_blocking() {
-                Ok(RequestJob::ProcessRequest(request)) => {
+                Ok(RequestJob::ProcessHttpRequest(request, app_proc)) => {
+                    self_ref.request_id.fetch_add(1, Ordering::Relaxed);
+                    self_ref.current_request_start.store(
+                        SystemTime::now()
+                            .duration_since(UNIX_EPOCH)
+                            .unwrap()
+                            .as_secs(),
+                        Ordering::Relaxed,
+                    );
+                    call_with_gvl(|_ruby| {
+                        request.process(&ruby, app_proc).ok();
+                    });
                     if terminated.load(Ordering::Relaxed) {
                         break;
                     }
+                }
+                Ok(RequestJob::ProcessGrpcRequest(request, app_proc)) => {
+                    self_ref.request_id.fetch_add(1, Ordering::Relaxed);
+                    self_ref.current_request_start.store(
+                        SystemTime::now()
+                            .duration_since(UNIX_EPOCH)
+                            .unwrap()
+                            .as_secs(),
+                        Ordering::Relaxed,
+                    );
                     call_with_gvl(|_ruby| {
-                        request.process(&ruby, server, app).ok();
-                    })
+                        request.process(&ruby, app_proc).ok();
+                    });
+                    if terminated.load(Ordering::Relaxed) {
+                        break;
+                    }
                 }
                 Ok(RequestJob::Shutdown) => {
-                    debug!("Shutting down thread worker");
                     break;
                 }
                 Err(_) => {