itsi-server 0.2.14 → 0.2.16

data/ext/itsi_server/src/server/middleware_stack/middlewares/rate_limit.rs

@@ -6,6 +6,7 @@ use crate::services::rate_limiter::{
 };
 use async_trait::async_trait;
 use either::Either;
+use http::{HeaderName, HeaderValue};
 use magnus::error::Result;
 use serde::Deserialize;
 use std::collections::HashMap;
@@ -24,6 +25,8 @@ pub struct RateLimit {
     pub trusted_proxies: HashMap<String, TokenSource>,
     #[serde(default = "too_many_requests_error_response")]
     pub error_response: ErrorResponse,
+    #[serde(skip)]
+    pub limit_header_value: OnceLock<HeaderValue>,
 }
 
 fn too_many_requests_error_response() -> ErrorResponse {
@@ -38,6 +41,12 @@ pub enum RateLimitKey {
     Parameter(TokenSource),
 }
 
+static X_RATELIMIT_LIMIT: HeaderName = HeaderName::from_static("x-ratelimit-limit");
+static X_RATELIMIT_REMAINING: HeaderName = HeaderName::from_static("x-ratelimit-remaining");
+static X_RATELIMIT_RESET: HeaderName = HeaderName::from_static("x-ratelimit-reset");
+static RETRY_AFTER: HeaderName = HeaderName::from_static("retry-after");
+static ZERO_VALUE: HeaderValue = HeaderValue::from_static("0");
+
 #[async_trait]
 impl MiddlewareLayer for RateLimit {
     async fn initialize(&self) -> Result<()> {
@@ -46,6 +55,9 @@ impl MiddlewareLayer for RateLimit {
         if let Ok(limiter) = get_rate_limiter(&self.store_config).await {
             let _ = self.rate_limiter.set(limiter);
         }
+        self.limit_header_value
+            .set(self.requests.to_string().parse().unwrap())
+            .ok();
         Ok(())
     }
 
@@ -58,8 +70,7 @@ impl MiddlewareLayer for RateLimit {
         let key_value = match &self.key {
             RateLimitKey::SocketAddress => {
                 // Use the socket address from the context
-                if self.trusted_proxies.contains_key(&context.addr) {
-                    let source = self.trusted_proxies.get(&context.addr).unwrap();
+                if let Some(source) = self.trusted_proxies.get(&context.addr) {
                     source.extract_token(&req).unwrap_or(&context.addr)
                 } else {
                     &context.addr
@@ -114,18 +125,20 @@ impl MiddlewareLayer for RateLimit {
                         .error_response
                         .to_http_response(req.accept().into())
                         .await;
+                    let ttl_header_value: HeaderValue = ttl.to_string().parse().unwrap();
+                    response.headers_mut().insert(
+                        X_RATELIMIT_LIMIT.clone(),
+                        self.limit_header_value.get().unwrap().clone(),
+                    );
                     response
                         .headers_mut()
-                        .insert("X-RateLimit-Limit", limit.to_string().parse().unwrap());
-                    response
-                        .headers_mut()
-                        .insert("X-RateLimit-Remaining", "0".parse().unwrap());
+                        .insert(X_RATELIMIT_REMAINING.clone(), ZERO_VALUE.clone());
                     response
                         .headers_mut()
-                        .insert("X-RateLimit-Reset", ttl.to_string().parse().unwrap());
+                        .insert(X_RATELIMIT_RESET.clone(), ttl_header_value.clone());
                     response
                         .headers_mut()
-                        .insert("Retry-After", ttl.to_string().parse().unwrap());
+                        .insert(RETRY_AFTER.clone(), ttl_header_value);
                     Ok(Either::Right(response))
                 }
                 Err(e) => {

data/ext/itsi_server/src/server/middleware_stack/middlewares/ruby_app.rs

@@ -119,11 +119,7 @@ impl MiddlewareLayer for RubyApp {
         if self.sendfile {
             if let Some(sendfile_header) = resp.headers().get("X-Sendfile") {
                 return ROOT_STATIC_FILE_SERVER
-                    .serve_single_abs(
-                        sendfile_header.to_str().unwrap(),
-                        context.accept.clone(),
-                        &[],
-                    )
+                    .serve_single_abs(sendfile_header.to_str().unwrap(), context.accept, &[])
                     .await;
             }
         }

data/ext/itsi_server/src/server/middleware_stack/middlewares/static_assets.rs

@@ -16,10 +16,15 @@ use http::{
 };
 use itsi_error::ItsiError;
 use magnus::error::Result;
-use moka::sync::Cache;
+use quick_cache::sync::Cache;
 use regex::Regex;
 use serde::Deserialize;
-use std::{collections::HashMap, path::PathBuf, sync::OnceLock, time::Duration};
+use std::{
+    collections::HashMap,
+    path::PathBuf,
+    sync::{Arc, OnceLock},
+    time::Duration,
+};
 use tracing::debug;
 
 #[derive(Debug, Deserialize)]
@@ -76,10 +81,7 @@ impl MiddlewareLayer for StaticAssets {
                 recheck_interval: Duration::from_secs(self.file_check_interval),
                 serve_hidden_files: self.serve_hidden_files,
                 allowed_extensions: self.allowed_extensions.clone(),
-                miss_cache: Cache::builder()
-                    .max_capacity(self.max_files_in_memory)
-                    .time_to_live(Duration::from_secs(self.file_check_interval))
-                    .build(),
+                miss_cache: Arc::new(Cache::new(self.max_files_in_memory as usize)),
             })?)
             .map_err(ItsiError::new)?;
         Ok(())

data/ext/itsi_server/src/server/middleware_stack/middlewares/static_response.rs

@@ -21,6 +21,10 @@ pub struct StaticResponse {
     body: Vec<u8>,
     #[serde(skip)]
     header_map: OnceLock<HeaderMap>,
+    #[serde(skip)]
+    body_bytes: OnceLock<Full<Bytes>>,
+    #[serde(skip)]
+    status_code: OnceLock<StatusCode>,
 }
 
 #[async_trait]
@@ -35,6 +39,12 @@ impl MiddlewareLayer for StaticResponse {
         self.header_map
             .set(header_map)
             .map_err(|_| ItsiError::new("Failed to set headers"))?;
+        self.body_bytes
+            .set(Full::new(Bytes::from(self.body.clone())))
+            .map_err(|_| ItsiError::new("Failed to set body bytes"))?;
+        self.status_code
+            .set(StatusCode::from_u16(self.code).unwrap_or(StatusCode::OK))
+            .map_err(|_| ItsiError::new("Failed to set status code"))?;
         Ok(())
     }
 
@@ -43,9 +53,8 @@ impl MiddlewareLayer for StaticResponse {
         _req: HttpRequest,
         _context: &mut HttpRequestContext,
     ) -> Result<Either<HttpRequest, HttpResponse>> {
-        let mut resp = Response::new(BoxBody::new(Full::new(Bytes::from(self.body.clone()))));
-        let status = StatusCode::from_u16(self.code).unwrap_or(StatusCode::OK);
-        *resp.status_mut() = status;
+        let mut resp = Response::new(BoxBody::new(self.body_bytes.get().unwrap().clone()));
+        *resp.status_mut() = *self.status_code.get().unwrap();
         *resp.headers_mut() = self.header_map.get().unwrap().clone();
 
         Ok(Either::Right(resp))

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

@@ -42,7 +42,8 @@ impl Default for ProcessWorker {
     }
 }
 
-static CORE_IDS: LazyLock<Vec<CoreId>> = LazyLock::new(|| core_affinity::get_core_ids().unwrap());
+pub static CORE_IDS: LazyLock<Vec<CoreId>> =
+    LazyLock::new(|| core_affinity::get_core_ids().unwrap());
 
 impl ProcessWorker {
     #[instrument(skip(self, cluster_template), fields(self.worker_id = %self.worker_id))]

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

@@ -0,0 +1,96 @@
+use std::{ops::Deref, pin::Pin, sync::Arc, time::Duration};
+
+use hyper_util::rt::TokioIo;
+use tokio::task::JoinSet;
+use tracing::debug;
+
+use crate::{
+    ruby_types::itsi_server::itsi_server_config::ServerParams,
+    server::{binds::listener::ListenerInfo, io_stream::IoStream, request_job::RequestJob},
+    services::itsi_http_service::{ItsiHttpService, ItsiHttpServiceInner},
+};
+
+use super::single_mode::{RunningPhase, SingleMode};
+
+pub struct Acceptor {
+    pub acceptor_args: Arc<AcceptorArgs>,
+    pub join_set: JoinSet<()>,
+}
+
+impl Deref for Acceptor {
+    type Target = Arc<AcceptorArgs>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.acceptor_args
+    }
+}
+
+pub struct AcceptorArgs {
+    pub strategy: Arc<SingleMode>,
+    pub listener_info: ListenerInfo,
+    pub shutdown_receiver: tokio::sync::watch::Receiver<RunningPhase>,
+    pub job_sender: async_channel::Sender<RequestJob>,
+    pub nonblocking_sender: async_channel::Sender<RequestJob>,
+    pub server_params: Arc<ServerParams>,
+}
+
+impl Acceptor {
+    pub(crate) async fn serve_connection(&mut self, stream: IoStream) {
+        let addr = stream.addr();
+        let io: TokioIo<Pin<Box<IoStream>>> = TokioIo::new(Box::pin(stream));
+        let mut shutdown_channel = self.shutdown_receiver.clone();
+        let acceptor_args = self.acceptor_args.clone();
+        self.join_set.spawn(async move {
+            let executor = &acceptor_args.strategy.executor;
+            let mut serve = Box::pin(executor.serve_connection_with_upgrades(
+                io,
+                ItsiHttpService {
+                    inner: Arc::new(ItsiHttpServiceInner {
+                        acceptor_args: acceptor_args.clone(),
+                        addr: addr.to_string(),
+                    }),
+                },
+            ));
+
+            tokio::select! {
+                // Await the connection finishing naturally.
+                res = &mut serve => {
+                    match res {
+                        Ok(()) => {
+                            debug!("Connection closed normally");
+                        },
+                        Err(res) => {
+                            debug!("Connection closed abruptly: {:?}", res);
+                        }
+                    }
+                    serve.as_mut().graceful_shutdown();
+                },
+                // A lifecycle event triggers shutdown.
+                _ = shutdown_channel.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);
+                    }
+                }
+            }
+        });
+    }
+
+    pub async fn join(&mut self) {
+        // Join all acceptor tasks with timeout
+        let deadline = tokio::time::Instant::now()
+            + Duration::from_secs_f64(self.server_params.shutdown_timeout);
+        let sleep_until = tokio::time::sleep_until(deadline);
+        tokio::select! {
+            _ = async {
+                while (self.join_set.join_next().await).is_some() {}
+            } => {},
+            _ = sleep_until => {
+                debug!("Shutdown timeout reached; abandoning remaining acceptor tasks.");
+            }
+        }
+    }
+}

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

@@ -4,6 +4,7 @@ use cluster_mode::ClusterMode;
 use itsi_error::Result;
 use single_mode::SingleMode;
 
+pub mod acceptor;
 pub mod cluster_mode;
 pub mod single_mode;
 

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

@@ -1,17 +1,15 @@
 use crate::{
     ruby_types::itsi_server::itsi_server_config::ItsiServerConfig,
     server::{
-        binds::listener::ListenerInfo,
-        io_stream::IoStream,
         lifecycle_event::LifecycleEvent,
         request_job::RequestJob,
+        serve_strategy::acceptor::{Acceptor, AcceptorArgs},
         signal::{SHUTDOWN_REQUESTED, SIGNAL_HANDLER_CHANNEL},
         thread_worker::{build_thread_workers, ThreadWorker},
     },
-    services::itsi_http_service::{ItsiHttpService, ItsiHttpServiceInner},
 };
 use hyper_util::{
-    rt::{TokioExecutor, TokioIo, TokioTimer},
+    rt::{TokioExecutor, TokioTimer},
     server::conn::auto::Builder,
 };
 use itsi_error::{ItsiError, Result};
@@ -22,13 +20,10 @@ use itsi_tracing::{debug, error, info};
 use magnus::{value::ReprValue, Value};
 use nix::unistd::Pid;
 use parking_lot::RwLock;
+use std::sync::Arc;
 use std::{
     collections::HashMap,
-    pin::Pin,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc,
-    },
+    sync::atomic::{AtomicBool, Ordering},
     thread::sleep,
     time::{Duration, Instant, SystemTime, UNIX_EPOCH},
 };
@@ -60,8 +55,22 @@ impl SingleMode {
     #[instrument(parent=None, skip_all)]
     pub fn new(server_config: Arc<ItsiServerConfig>) -> Result<Self> {
         server_config.server_params.read().preload_ruby()?;
+        let mut executor = Builder::new(TokioExecutor::new());
+        executor
+            .http1()
+            .header_read_timeout(server_config.server_params.read().header_read_timeout)
+            .writev(true)
+            .timer(TokioTimer::new());
+        executor
+            .http2()
+            .max_concurrent_streams(100)
+            .max_local_error_reset_streams(100)
+            .enable_connect_protocol()
+            .max_header_list_size(10 * 1024 * 1024)
+            .max_send_buf_size(16 * 1024 * 1024);
+
         Ok(Self {
-            executor: Builder::new(TokioExecutor::new()),
+            executor,
             server_config,
             lifecycle_channel: SIGNAL_HANDLER_CHANNEL.0.clone(),
             restart_requested: AtomicBool::new(false),
@@ -82,7 +91,11 @@ impl SingleMode {
         };
         builder
             .thread_name("itsi-server-accept-loop")
-            .thread_stack_size(3 * 1024 * 1024)
+            .thread_stack_size(512 * 1024)
+            .max_blocking_threads(4)
+            .event_interval(16)
+            .global_queue_interval(64)
+            .max_io_events_per_tick(256)
             .enable_all()
             .build()
             .expect("Failed to build Tokio runtime")
@@ -214,9 +227,6 @@ impl SingleMode {
 
     #[instrument(name="worker", parent=None, skip(self), fields(pid=format!("{}", Pid::this())))]
     pub fn run(self: Arc<Self>) -> Result<()> {
-        let mut listener_task_set = JoinSet::new();
-        let runtime = self.build_runtime();
-
         let (thread_workers, job_sender, nonblocking_sender) =
             build_thread_workers(self.server_config.server_params.read().clone(), Pid::this())
                 .inspect_err(|e| {
@@ -225,11 +235,13 @@ impl SingleMode {
                     }
                 })?;
 
+        let worker_count = thread_workers.len();
         info!(
-            threads = thread_workers.len(),
+            threads = worker_count,
             binds = format!("{:?}", self.server_config.server_params.read().binds)
         );
 
+        let shutdown_timeout = self.server_config.server_params.read().shutdown_timeout;
         let (shutdown_sender, _) = watch::channel(RunningPhase::Running);
         let monitor_thread = self.clone().start_monitors(thread_workers.clone());
         if monitor_thread.is_none() {
@@ -240,8 +252,10 @@ impl SingleMode {
         if SHUTDOWN_REQUESTED.load(Ordering::SeqCst) {
             return Ok(());
         }
+        let runtime = self.build_runtime();
         let result = runtime.block_on(
           async  {
+              let mut listener_task_set = JoinSet::new();
               let server_params = self.server_config.server_params.read().clone();
               if let Err(err) = server_params.initialize_middleware().await {
                   error!("Failed to initialize middleware: {}", err);
@@ -254,80 +268,72 @@ impl SingleMode {
                   })
                   .collect::<Vec<_>>();
 
-              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();
+              tokio_listeners.iter().cloned().for_each(|listener| {
                   let shutdown_sender = shutdown_sender.clone();
                   let job_sender = job_sender.clone();
                   let nonblocking_sender = nonblocking_sender.clone();
-                  let workers_clone = thread_workers.clone();
-                  let listener_clone = listener.clone();
+
+                  let mut lifecycle_rx = self.lifecycle_channel.subscribe();
                   let mut shutdown_receiver = shutdown_sender.subscribe();
-                  let shutdown_receiver_clone = shutdown_receiver.clone();
+                  let mut acceptor = Acceptor{
+                      acceptor_args: Arc::new(
+                        AcceptorArgs{
+                          strategy: self.clone(),
+                          listener_info: listener.listener_info(),
+                          shutdown_receiver: shutdown_sender.subscribe(),
+                          job_sender: job_sender.clone(),
+                          nonblocking_sender: nonblocking_sender.clone(),
+                          server_params: server_params.clone()
+                        }
+                      ),
+                      join_set: JoinSet::new()
+                  };
+
+                  let shutdown_rx_for_acme_task = shutdown_receiver.clone();
+                  let acme_task_listener_clone = listener.clone();
                   listener_task_set.spawn(async move {
-                    listener_clone.spawn_state_task(shutdown_receiver_clone).await;
+                      acme_task_listener_clone.spawn_acme_event_task(shutdown_rx_for_acme_task).await;
                   });
 
                   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();
-                                let job_sender = job_sender.clone();
-                                let nonblocking_sender = nonblocking_sender.clone();
-                                acceptor_task_set.spawn(async move {
-                                  strategy.serve_connection(accept_result, job_sender, nonblocking_sender, listener_info, shutdown_receiver).await;
-                                });
+                      loop {
+                          tokio::select! {
+                              accept_result = listener.accept() => {
+                                  match accept_result {
+                                      Ok(accepted) => acceptor.serve_connection(accepted).await,
+                                      Err(e) => debug!("Listener.accept failed: {:?}", e)
+                                  }
                               },
-                              Err(e) => debug!("Listener.accept failed {:?}", e),
-                            },
-                            _ = shutdown_receiver.changed() => {
-                              break;
-                            }
-                            lifecycle_event = lifecycle_rx.recv() => match lifecycle_event{
-                              Ok(LifecycleEvent::Shutdown) => {
-                                debug!("Received lifecycle event: {:?}", lifecycle_event);
-                                shutdown_sender.send(RunningPhase::ShutdownPending).unwrap();
-                                tokio::time::sleep(Duration::from_millis(25)).await;
-                                for _i in 0..workers_clone.len() {
-                                  job_sender.send(RequestJob::Shutdown).await.unwrap();
-                                  nonblocking_sender.send(RequestJob::Shutdown).await.unwrap();
-                                }
-                                break;
+                              _ = shutdown_receiver.changed() => {
+                                  debug!("Shutdown requested via receiver");
+                                  break;
                               },
-                              Err(e) => error!("Error receiving lifecycle_event: {:?}", e),
-                              _ => {}
+                              lifecycle_event = lifecycle_rx.recv() => {
+                                  match lifecycle_event {
+                                      Ok(LifecycleEvent::Shutdown) => {
+                                          debug!("Received LifecycleEvent::Shutdown");
+                                          let _ = shutdown_sender.send(RunningPhase::ShutdownPending);
+                                          for _ in 0..worker_count {
+                                              let _ = job_sender.send(RequestJob::Shutdown).await;
+                                              let _ = nonblocking_sender.send(RequestJob::Shutdown).await;
+                                          }
+                                          break;
+                                      },
+                                      Err(e) =>  error!("Error receiving lifecycle event: {:?}", e),
+                                      _ => ()
+                                  }
+                              }
                           }
-                        }
-                    }
-
-                    let deadline = Instant::now()
-                        + Duration::from_secs_f64(self_ref.server_config.server_params.read().shutdown_timeout);
-                    tokio::select! {
-                        _ = async {
-                            while let Some(_res) = acceptor_task_set.join_next().await {}
-                        } => {},
-                        _ = tokio::time::sleep_until(tokio::time::Instant::from_std(deadline)) => {},
-                    }
-                });
-
-              }
+                      }
+                      acceptor.join().await;
+                  });
+              });
 
               if self.is_single_mode() {
                 self.invoke_hook("after_start");
               }
 
               while let Some(_res) = listener_task_set.join_next().await {}
-
-              // Explicitly drop all listeners to ensure file descriptors are released
               drop(tokio_listeners);
 
               Ok::<(), ItsiError>(())
@@ -346,12 +352,10 @@ impl SingleMode {
         }
 
         shutdown_sender.send(RunningPhase::Shutdown).ok();
-        let deadline = Instant::now()
-            + Duration::from_secs_f64(self.server_config.server_params.read().shutdown_timeout);
-
         runtime.shutdown_timeout(Duration::from_millis(100));
-
         debug!("Shutdown timeout finished.");
+
+        let deadline = Instant::now() + Duration::from_secs_f64(shutdown_timeout);
         loop {
             if thread_workers
                 .iter()
@@ -380,66 +384,6 @@ impl SingleMode {
     pub fn is_single_mode(&self) -> bool {
         self.server_config.server_params.read().workers == 1
     }
-
-    pub(crate) async fn serve_connection(
-        &self,
-        stream: IoStream,
-        job_sender: async_channel::Sender<RequestJob>,
-        nonblocking_sender: async_channel::Sender<RequestJob>,
-        listener: Arc<ListenerInfo>,
-        shutdown_channel: watch::Receiver<RunningPhase>,
-    ) {
-        let addr = stream.addr();
-        let io: TokioIo<Pin<Box<IoStream>>> = TokioIo::new(Box::pin(stream));
-        let executor = self.executor.clone();
-        let mut shutdown_channel_clone = shutdown_channel.clone();
-        let mut executor = executor.clone();
-        let mut binding = executor.http1();
-        let shutdown_channel = shutdown_channel_clone.clone();
-
-        let service = ItsiHttpService {
-            inner: Arc::new(ItsiHttpServiceInner {
-                sender: job_sender.clone(),
-                nonblocking_sender: nonblocking_sender.clone(),
-                server_params: self.server_config.server_params.read().clone(),
-                listener,
-                addr: addr.to_string(),
-                shutdown_channel: shutdown_channel.clone(),
-            }),
-        };
-        let mut serve = Box::pin(
-            binding
-                .timer(TokioTimer::new())
-                .header_read_timeout(self.server_config.server_params.read().header_read_timeout)
-                .serve_connection_with_upgrades(io, service),
-        );
-
-        tokio::select! {
-            // Await the connection finishing naturally.
-            res = &mut serve => {
-                match res{
-                    Ok(()) => {
-                      debug!("Connection closed normally")
-                    },
-                    Err(res) => {
-                      debug!("Connection closed abruptly: {:?}", 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);
-                }
-            }
-        }
-    }
-
     /// Attempts to reload the config "live"
     /// Not that when running in single mode this will not unload
     /// old code. If you need a clean restart, use the `restart` (SIGHUP) method instead

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

@@ -23,9 +23,12 @@ use std::{
 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 crate::{
+    ruby_types::{
+        itsi_grpc_call::ItsiGrpcCall, itsi_http_request::ItsiHttpRequest,
+        itsi_server::itsi_server_config::ServerParams, ITSI_SERVER,
+    },
+    server::process_worker::CORE_IDS,
 };
 
 use super::request_job::RequestJob;
@@ -184,9 +187,13 @@ impl ThreadWorker {
         let scheduler_class = self.scheduler_class;
         let params = self.params.clone();
         let self_ref = self.clone();
+        let id = self.id;
         call_with_gvl(|_| {
             *self.thread.write() = Some(
                 create_ruby_thread(move || {
+                    if params.pin_worker_cores {
+                        core_affinity::set_for_current(CORE_IDS[(id as usize) % CORE_IDS.len()]);
+                    }
                     debug!("Ruby thread worker started");
                     if let Some(scheduler_class) = scheduler_class {
                         if let Err(err) = self_ref.fiber_accept_loop(