itsi-server 0.2.17 → 0.2.19

data/ext/itsi_server/src/ruby_types/itsi_server/itsi_server_config.rs

@@ -1,4 +1,4 @@
-use super::file_watcher::{self};
+use super::file_watcher::{self, WatcherCommand};
 use crate::{
     ruby_types::ITSI_SERVER_CONFIG,
     server::{
@@ -9,7 +9,7 @@ use crate::{
 use derive_more::Debug;
 use itsi_error::ItsiError;
 use itsi_rb_helpers::{call_with_gvl, print_rb_backtrace, HeapValue};
-use itsi_tracing::{set_format, set_level, set_target, set_target_filters};
+use itsi_tracing::{error, set_format, set_level, set_target, set_target_filters};
 use magnus::{
     block::Proc,
     error::Result,
@@ -18,12 +18,12 @@ use magnus::{
 };
 use nix::{
     fcntl::{fcntl, FcntlArg, FdFlag},
-    unistd::{close, dup},
+    unistd::dup,
 };
 use parking_lot::{Mutex, RwLock};
 use std::{
     collections::HashMap,
-    os::fd::{AsRawFd, OwnedFd, RawFd},
+    os::fd::RawFd,
     path::PathBuf,
     str::FromStr,
     sync::{
@@ -32,7 +32,7 @@ use std::{
     },
     time::Duration,
 };
-use tracing::{debug, error};
+use tracing::debug;
 static DEFAULT_BIND: &str = "http://localhost:3000";
 static ID_BUILD_CONFIG: LazyId = LazyId::new("build_config");
 static ID_RELOAD_EXEC: LazyId = LazyId::new("reload_exec");
@@ -44,7 +44,7 @@ pub struct ItsiServerConfig {
     pub itsi_config_proc: Arc<Option<HeapValue<Proc>>>,
     #[debug(skip)]
     pub server_params: Arc<RwLock<Arc<ServerParams>>>,
-    pub watcher_fd: Arc<Option<OwnedFd>>,
+    pub watcher_fd: Arc<Option<file_watcher::WatcherPipes>>,
 }
 
 #[derive(Debug)]
@@ -84,7 +84,7 @@ pub struct ServerParams {
     listener_info: Mutex<HashMap<String, i32>>,
     pub itsi_server_token_preference: ItsiServerTokenPreference,
     pub preloaded: AtomicBool,
-    socket_opts: SocketOpts,
+    pub socket_opts: SocketOpts,
     preexisting_listeners: Option<String>,
 }
 
@@ -442,6 +442,10 @@ impl ItsiServerConfig {
         }
     }
 
+    pub fn use_reuse_port_load_balancing(&self) -> bool {
+        cfg!(target_os = "linux") && self.server_params.read().socket_opts.reuse_port
+    }
+
     /// Reload
     pub fn reload(self: Arc<Self>, cluster_worker: bool) -> Result<bool> {
         let server_params = call_with_gvl(|ruby| {
@@ -553,6 +557,9 @@ impl ItsiServerConfig {
     }
 
     pub fn dup_fds(self: &Arc<Self>) -> Result<()> {
+        // Ensure the watcher is already stopped before duplicating file descriptors
+        // to prevent race conditions between closing the watcher FD and duplicating socket FDs
+
         let binding = self.server_params.read();
         let mut listener_info_guard = binding.listener_info.lock();
         let dupped_fd_map = listener_info_guard
@@ -578,8 +585,10 @@ impl ItsiServerConfig {
     }
 
     pub fn stop_watcher(self: &Arc<Self>) -> Result<()> {
-        if let Some(r_fd) = self.watcher_fd.as_ref() {
-            close(r_fd.as_raw_fd()).ok();
+        if let Some(pipes) = self.watcher_fd.as_ref() {
+            // Send explicit stop command to the watcher process
+            file_watcher::send_watcher_command(&pipes.write_fd, WatcherCommand::Stop)?;
+            // We don't close the pipes here - they'll be closed when the WatcherPipes is dropped
         }
         Ok(())
     }
@@ -594,8 +603,24 @@ impl ItsiServerConfig {
     pub async fn check_config(&self) -> bool {
         if let Some(errors) = self.get_config_errors().await {
             Self::print_config_errors(errors);
+            // Notify watcher that config check failed
+            if let Some(pipes) = self.watcher_fd.as_ref() {
+                if let Err(e) =
+                    file_watcher::send_watcher_command(&pipes.write_fd, WatcherCommand::ConfigError)
+                {
+                    error!("Failed to notify watcher of config error: {}", e);
+                }
+            }
             return false;
         }
+        // If we reach here, the config is valid
+        if let Some(pipes) = self.watcher_fd.as_ref() {
+            if let Err(e) =
+                file_watcher::send_watcher_command(&pipes.write_fd, WatcherCommand::Continue)
+            {
+                error!("Failed to notify watcher to continue: {}", e);
+            }
+        }
         true
     }
 
@@ -609,7 +634,8 @@ impl ItsiServerConfig {
                     )
                 })?;
 
-        self.stop_watcher()?;
+        // Make sure we're not calling stop_watcher here to avoid double-stopping
+        // The watcher should be stopped earlier in the restart sequence
         call_with_gvl(|ruby| -> Result<()> {
             ruby.get_inner_ref(&ITSI_SERVER_CONFIG)
                 .funcall::<_, _, Value>(*ID_RELOAD_EXEC, (listener_json,))?;

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

@@ -304,16 +304,16 @@ impl Listener {
         connect_tcp_socket(ip, port, &socket_opts).unwrap()
     }
 
-    pub fn into_tokio_listener(self, no_rebind: bool) -> TokioListener {
+    pub fn into_tokio_listener(self, should_rebind: bool) -> TokioListener {
         match self {
             Listener::Tcp(mut listener) => {
-                if cfg!(target_os = "linux") && !no_rebind {
+                if should_rebind {
                     listener = Listener::rebind_listener(listener);
                 }
                 TokioListener::Tcp(TokioTcpListener::from_std(listener).unwrap())
             }
             Listener::TcpTls((mut listener, acceptor)) => {
-                if cfg!(target_os = "linux") && !no_rebind {
+                if should_rebind {
                     listener = Listener::rebind_listener(listener);
                 }
                 TokioListener::TcpTls(

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

@@ -100,9 +100,11 @@ impl ClusterMode {
             LifecycleEvent::Restart => {
                 if self.server_config.check_config().await {
                     self.invoke_hook("before_restart");
+                    self.server_config.stop_watcher()?;
                     self.server_config.dup_fds()?;
                     self.shutdown().await.ok();
                     info!("Shutdown complete. Calling reload exec");
+
                     self.server_config.reload_exec()?;
                 }
                 Ok(())
@@ -111,8 +113,11 @@ impl ClusterMode {
                 if !self.server_config.check_config().await {
                     return Ok(());
                 }
+
                 let should_reexec = self.server_config.clone().reload(true)?;
+
                 if should_reexec {
+                    self.server_config.stop_watcher()?;
                     self.server_config.dup_fds()?;
                     self.shutdown().await.ok();
                     self.server_config.reload_exec()?;
@@ -321,15 +326,6 @@ impl ClusterMode {
             .iter()
             .try_for_each(|worker| worker.boot(Arc::clone(&self)))?;
 
-        if cfg!(target_os = "linux") {
-            self.server_config
-                .server_params
-                .write()
-                .listeners
-                .lock()
-                .drain(..);
-        };
-
         let (sender, mut receiver) = watch::channel(());
         *CHILD_SIGNAL_SENDER.lock() = Some(sender);
 
@@ -381,9 +377,13 @@ impl ClusterMode {
               }
               lifecycle_event = lifecycle_rx.recv() => match lifecycle_event{
                 Ok(lifecycle_event) => {
+                  debug!("Cluster mode received lifecycle event: {:?}", lifecycle_event);
                   if let Err(e) = self_ref.clone().handle_lifecycle_event(lifecycle_event).await{
                     match e {
-                      ItsiError::Break => break,
+                      ItsiError::Break => {
+                        debug!("Lifecycle event triggered shutdown, breaking cluster monitor loop");
+                        break;
+                      },
                       _ => error!("Error in handle_lifecycle_event {:?}", e)
                     }
                   }

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

@@ -262,7 +262,14 @@ impl SingleMode {
         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 we're on Linux with reuse_port enabled, we can use
+        // kernel level load balancing across processes sharing a port.
+        // To take advantage of this, these forks will rebind to the same port upon boot.
+        // Worker 0 is special (this one just inherits the bind from the master process).
         let is_zero_worker = self.is_zero_worker();
+        let should_rebind = !is_zero_worker && self.server_config.use_reuse_port_load_balancing();
+
         if monitor_thread.is_none() {
             error!("Failed to start monitor thread");
             return Err(ItsiError::new("Failed to start monitor thread"));
@@ -283,7 +290,7 @@ impl SingleMode {
                 .listeners
                 .lock()
                 .drain(..)
-                .map(|list| Arc::new(list.into_tokio_listener(is_zero_worker)))
+                .map(|list| Arc::new(list.into_tokio_listener(should_rebind)))
                 .collect::<Vec<_>>();
 
             tokio_listeners.iter().cloned().for_each(|listener| {
@@ -311,7 +318,7 @@ impl SingleMode {
                 let mut after_accept_wait: Option<Duration> = None::<Duration>;
 
                 if cfg!(target_os = "macos") {
-                    after_accept_wait = if server_params.workers > 1 {
+                    after_accept_wait = if server_params.workers > 1 && !(server_params.socket_opts.reuse_port && server_params.socket_opts.reuse_address) {
                         Some(Duration::from_nanos(10 * server_params.workers as u64))
                     } else {
                         None
@@ -434,6 +441,7 @@ impl SingleMode {
         if self.is_single_mode() {
             self.invoke_hook("before_restart");
         }
+        self.server_config.stop_watcher()?;
         self.server_config.dup_fds()?;
         self.server_config.reload_exec()?;
         Ok(())

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

@@ -1,11 +1,12 @@
 use std::{
     collections::VecDeque,
-    sync::atomic::{AtomicBool, AtomicI8},
+    sync::atomic::{AtomicBool, AtomicI8, Ordering},
 };
 
 use nix::libc::{self, sighandler_t};
 use parking_lot::Mutex;
 use tokio::sync::broadcast;
+use tracing::{debug, warn};
 
 use super::lifecycle_event::LifecycleEvent;
 
@@ -21,12 +22,14 @@ pub fn subscribe_runtime_to_signals() -> broadcast::Receiver<LifecycleEvent> {
     if let Some(sender) = guard.as_ref() {
         return sender.subscribe();
     }
-    let (sender, receiver) = broadcast::channel(5);
+    let (sender, receiver) = broadcast::channel(32);
     let sender_clone = sender.clone();
     std::thread::spawn(move || {
-        std::thread::sleep(std::time::Duration::from_millis(50));
+        std::thread::sleep(std::time::Duration::from_millis(10));
         for event in PENDING_QUEUE.lock().drain(..) {
-            sender_clone.send(event).ok();
+            if let Err(e) = sender_clone.send(event) {
+                eprintln!("Warning: Failed to send pending lifecycle event {:?}", e);
+            }
         }
     });
 
@@ -41,22 +44,36 @@ pub fn unsubscribe_runtime() {
 
 pub fn send_lifecycle_event(event: LifecycleEvent) {
     if let Some(sender) = SIGNAL_HANDLER_CHANNEL.lock().as_ref() {
-        sender.send(event).ok();
+        if let Err(e) = sender.send(event) {
+            // Channel full or receivers dropped - this is a critical error for shutdown signals
+            eprintln!("Critical: Failed to send lifecycle event {:?}", e);
+            // For shutdown events, try to force exit if channel delivery fails
+            if matches!(
+                e.0,
+                LifecycleEvent::Shutdown | LifecycleEvent::ForceShutdown
+            ) {
+                eprintln!("Emergency shutdown due to signal delivery failure");
+                std::process::exit(1);
+            }
+        }
     } else {
         PENDING_QUEUE.lock().push_back(event);
     }
 }
 
 fn receive_signal(signum: i32, _: sighandler_t) {
-    SIGINT_COUNT.fetch_add(-1, std::sync::atomic::Ordering::SeqCst);
+    debug!("Received signal: {}", signum);
+    SIGINT_COUNT.fetch_add(-1, Ordering::SeqCst);
     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 {
+            debug!("Received shutdown signal (SIGTERM/SIGINT)");
+            SHUTDOWN_REQUESTED.store(true, Ordering::SeqCst);
+            SIGINT_COUNT.fetch_add(2, Ordering::SeqCst);
+            if SIGINT_COUNT.load(Ordering::SeqCst) < 2 {
+                debug!("First shutdown signal, requesting graceful shutdown");
                 Some(LifecycleEvent::Shutdown)
             } else {
-                // Not messing about. Force shutdown.
+                warn!("Multiple shutdown signals received, forcing immediate shutdown");
                 Some(LifecycleEvent::ForceShutdown)
             }
         }
@@ -70,13 +87,17 @@ fn receive_signal(signum: i32, _: sighandler_t) {
     };
 
     if let Some(event) = event {
+        debug!("Signal {} mapped to lifecycle event: {:?}", signum, event);
         send_lifecycle_event(event);
+    } else {
+        debug!("Signal {} not mapped to any lifecycle event", signum);
     }
 }
 
 pub fn reset_signal_handlers() -> bool {
-    SIGINT_COUNT.store(0, std::sync::atomic::Ordering::SeqCst);
-    SHUTDOWN_REQUESTED.store(false, std::sync::atomic::Ordering::SeqCst);
+    debug!("Resetting signal handlers");
+    SIGINT_COUNT.store(0, Ordering::SeqCst);
+    SHUTDOWN_REQUESTED.store(false, Ordering::SeqCst);
 
     unsafe {
         libc::signal(libc::SIGTERM, receive_signal as usize);
@@ -92,6 +113,7 @@ pub fn reset_signal_handlers() -> bool {
 }
 
 pub fn clear_signal_handlers() {
+    debug!("Clearing signal handlers");
     unsafe {
         libc::signal(libc::SIGTERM, libc::SIG_DFL);
         libc::signal(libc::SIGINT, libc::SIG_DFL);

data/lib/itsi/server/config/dsl.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# typed: true
+
 module Itsi
   class Server
     module Config
@@ -55,9 +58,7 @@ module Itsi
             nested_locations: [],
             middleware_loader: lambda do
               @options[:nested_locations].each(&:call)
-              if !(@middleware[:app] || @middleware[:static_assets])
-                @middleware[:app] = { app_proc: DEFAULT_APP[]}
-              end
+              @middleware[:app] = { app_proc: DEFAULT_APP[] } unless @middleware[:app] || @middleware[:static_assets]
               [flatten_routes, Config.errors_to_error_lines(errors)]
             end
           }
@@ -75,7 +76,7 @@ module Itsi
           define_method(option_name) do |*args, **kwargs, &blk|
             option.new(self, *args, **kwargs, &blk).build!
           rescue Exception => e # rubocop:disable Lint/RescueException
-            @errors << [e, e.backtrace.find{|r| !(r =~ /server\/config/) }]
+            @errors << [e, e.backtrace.find { |r| !(r =~ %r{server/config}) }]
           end
         end
 
@@ -86,7 +87,7 @@ module Itsi
           rescue Config::Endpoint::InvalidHandlerException => e
             @errors << [e, "#{e.backtrace[0]}:in #{e.message}"]
           rescue Exception => e # rubocop:disable Lint/RescueException
-            @errors << [e, e.backtrace.find{|r| !(r =~ /server\/config/) }]
+            @errors << [e, e.backtrace.find { |r| !(r =~ %r{server/config}) }]
           end
         end
 

data/lib/itsi/server/config/middleware/compression.md

@@ -13,7 +13,7 @@ You can enable several different compression algorithms, and choose to selective
     min_size: 1024 # 1KiB,
     algorithms: %w[zstd gzip deflate br],
     compress_streams: true,
-    mime_types: %[all],
+    mime_types: %w[all],
     level: "fastest"
 ```
 
@@ -24,7 +24,7 @@ You can enable several different compression algorithms, and choose to selective
     compress \
       min_size: 1024 # 1KiB,
       algorithms: %w[zstd gzip deflate br],
-      mime_types: %[image],
+      mime_types: %w[image],
       level: "fastest"
 
     static_assets: \
@@ -47,4 +47,4 @@ You can enable several different compression algorithms, and choose to selective
 # Pre-compressed `static_assets`
 Itsi also supports serving pre-compressed static assets directly from the file-system.
 This is configured inside the `static_assets` middleware.
-Go to the [static_assets](/middleware/static_assets.md) middleware for more information.
+Go to the [static_assets](/middleware/static_assets) middleware for more information.

data/lib/itsi/server/config/middleware/endpoint/controller.md

@@ -181,6 +181,6 @@ module UserController
   end
 end
 
-controller User
+controller UserController
 post "/", :create
 ```

data/lib/itsi/server/config/middleware/proxy.md

@@ -12,7 +12,7 @@ proxy \
   to: "http://backend.example.com/api{path}{query}",
   backends: ["127.0.0.1:3001", "127.0.0.1:3002"],
   backend_priority: "round_robin",
-  headers: { "X-Forwarded-For" => { rewrite: "{addr}" } },
+  headers: { "X-Forwarded-For" => "{addr}" },
   verify_ssl: false,
   timeout: 30,
   tls_sni: true,
@@ -54,7 +54,7 @@ proxy \
 3. **Header Overrides**
    The `headers` option lets you specify extra or overriding headers. Each header value may be a literal or a string rewrite. For example, overriding `"X-Forwarded-For"` to carry the client’s IP is done by:
    ```ruby
-   { "X-Forwarded-For" => { rewrite: "{addr}" } }
+   { "X-Forwarded-For" => "{addr}" }
    ```
 
 4. **Request Forwarding and Error Handling**

data/lib/itsi/server/config/middleware/rate_limit.md

@@ -39,7 +39,7 @@ How to identify the client:
   ```
   or
   ```ruby
-  key: { parameter: { query:  { name: "user_id" } } }
+  key: { parameter: { query: "user_id" } }
   ```
 
 ### `store_config`

data/lib/itsi/server/config/options/auto_reload_config.rb

@@ -2,9 +2,8 @@ module Itsi
   class Server
     module Config
       class AutoReloadConfig < Option
-
         insert_text <<~SNIPPET
-        auto_reload_config! # Auto-reload the server configuration each time it changes.
+          auto_reload_config! # Auto-reload the server configuration each time it changes.
         SNIPPET
 
         detail "Auto-reload the server configuration each time it changes."
@@ -15,18 +14,20 @@ module Itsi
 
         def build!
           return if @auto_reloading
-          src = caller.find{|l| !(l =~ /lib\/itsi\/server\/config/) }.split(":").first
+
+          src = caller.find { |l| !(l =~ %r{lib/itsi/server/config}) }.split(":").first
 
           location.instance_eval do
             return if @auto_reloading
 
             if @included
               @included.each do |file|
-                next if  "#{file}.rb" == src
+                next if "#{file}" == src
+
                 if ENV["BUNDLE_BIN_PATH"]
-                  watch "#{file}.rb", [%w[bundle exec itsi restart]]
+                  watch "#{file}", [%w[bundle exec itsi restart]]
                 else
-                  watch "#{file}.rb", [%w[itsi restart]]
+                  watch "#{file}", [%w[itsi restart]]
                 end
               end
             end

data/lib/itsi/server/config/options/include.md

@@ -7,6 +7,7 @@ Use the `include` option to load additional files to be evaluated within the cur
 You can use this option to split a large configuration file into multiple smaller files.
 
 Files required using `include` are also subject to auto-reloading, when using the [auto_reload_config](/options/auto_reload_config) option.
+The path of the included file is evaluated relative to the current configuration file.
 
 ## Examples
 ```ruby {filename="Itsi.rb"}

data/lib/itsi/server/config/options/include.rb

@@ -2,37 +2,39 @@ module Itsi
   class Server
     module Config
       class Include < Option
-
         insert_text "include \"${1|other_file|}\" # Include another file to be loaded within the current configuration"
 
         detail "Include another file to be loaded within the current configuration"
 
         schema do
-          Type(String)
+          Type(String) & Required()
         end
 
         def build!
-          included_file = @params
+          caller_location = caller_locations(2, 1).first.path
+          included_file = \
+            if caller_location =~ %r{lib/itsi/server}
+              File.expand_path("#{@params}.rb")
+            else
+              File.expand_path("#{@params}.rb", File.dirname(caller_location))
+            end
+
           location.instance_eval do
             @included ||= []
             @included << included_file
 
             if @auto_reloading
               if ENV["BUNDLE_BIN_PATH"]
-                watch "#{included_file}.rb", [%w[bundle exec itsi restart]]
+                watch "#{included_file}", [%w[bundle exec itsi restart]]
               else
-                watch "#{included_file}.rb", [%w[itsi restart]]
+                watch "#{included_file}", [%w[itsi restart]]
               end
             end
           end
 
-          filename =  File.expand_path("#{included_file}.rb")
-
-          code = IO.read(filename)
-          location.instance_eval(code, filename, 1)
-
+          code = IO.read(included_file)
+          location.instance_eval(code, included_file, 1)
         end
-
       end
     end
   end

data/lib/itsi/server/config/options/reuse_port.rb

@@ -2,17 +2,15 @@ module Itsi
   class Server
     module Config
       class ReusePort < Option
-
         insert_text <<~SNIPPET
-        reuse_port ${1|true,false|}
+          reuse_port ${1|true,false|}
         SNIPPET
 
         detail "Configures whether the server should set the reuse_port option on the underlying socket."
 
         schema do
-          (Bool() & Required()).default(false)
+          (Bool() & Required()).default(true)
         end
-
       end
     end
   end

data/lib/itsi/server/config.rb

@@ -97,7 +97,7 @@ module Itsi
             errors << [e, e.backtrace[0]]
           end
         # If we're just preloading a specific gem group, we'll do that here too
-        when Symbol
+        when Symbol, String
           Itsi.log_debug("Preloading gem group #{preload}")
           Bundler.require(preload)
         end

data/lib/itsi/server/default_config/Itsi.rb

@@ -10,7 +10,7 @@ env = ENV.fetch("APP_ENV") { ENV.fetch("RACK_ENV", "development") }
 
 # Number of worker processes to spawn
 # If more than 1, Itsi will be booted in Cluster mode
-workers ENV["ITSI_WORKERS"]&.to_i || env == "development" ? 1 : nil
+workers ENV["ITSI_WORKERS"]&.to_i || (env == "development" ? 1 : nil)
 
 # Number of threads to spawn per worker process
 # For pure CPU bound applicationss, you'll get the best results keeping this number low
@@ -27,11 +27,13 @@ threads ENV.fetch("ITSI_THREADS", 3)
 fiber_scheduler nil
 
 # If you bind to https, without specifying a certificate, Itsi will use a self-signed certificate.
-# The self-signed certificate will use a CA generated for your host and stored inside `ITSI_LOCAL_CA_DIR` (Defaults to ~/.itsi)
+# The self-signed certificate will use a CA generated for your
+# host and stored inside `ITSI_LOCAL_CA_DIR` (Defaults to ~/.itsi)
 # bind "https://0.0.0.0:3000"
 # bind "https://0.0.0.0:3000?domains=dev.itsi.fyi"
 #
-# If you want to use let's encrypt to generate you a real certificate you and pass cert=acme and an acme_email address to generate one.
+# If you want to use let's encrypt to generate you a real certificate you
+# and pass cert=acme and an acme_email address to generate one.
 # bind "https://itsi.fyi?cert=acme&acme_email=admin@itsi.fyi"
 # You can generate certificates for multiple domains at once, by passing a comma-separated list of domains
 # bind "https://0.0.0.0?domains=foo.itsi.fyi,bar.itsi.fyi&cert=acme&acme_email=admin@itsi.fyi"
@@ -68,7 +70,8 @@ preload true
 # all of them at once, if they reach the threshold simultaneously.
 worker_memory_limit 1024 * 1024 * 1024
 
-# You can provide an optional block of code to run, when a worker hits its memory threshold (Use this to send yourself an alert,
+# You can provide an optional block of code to run, when a worker hits its memory threshold
+# (Use this to send yourself an alert,
 # write metrics to disk etc. etc.)
 after_memory_limit_reached do |pid|
   puts "Worker #{pid} has reached its memory threshold and will restart"
@@ -85,7 +88,8 @@ after_fork {}
 shutdown_timeout 5
 
 # Set this to false for application environments that require rack.input to be a rewindable body
-# (like Rails). For rack applications that can stream inputs, you can set this to true for a more memory-efficient approach.
+# (like Rails). For rack applications that can stream inputs, you can set this to true for a more
+# memory-efficient approach.
 stream_body false
 
 # OOB GC responses threshold

data/lib/itsi/server/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Server
-    VERSION = "0.2.17"
+    VERSION = "0.2.19"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: itsi-server
 version: !ruby/object:Gem::Version
-  version: 0.2.17
+  version: 0.2.19
 platform: ruby
 authors:
 - Wouter Coppieters