itsi-server 0.1.19 → 0.1.20

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

@@ -7,8 +7,9 @@ use crate::{
     },
 };
 use derive_more::Debug;
+use futures::executor::block_on;
 use itsi_rb_helpers::{call_with_gvl, print_rb_backtrace, HeapValue};
-use itsi_tracing::{set_format, set_level, set_target};
+use itsi_tracing::{set_format, set_level, set_target, set_target_filters};
 use magnus::{
     block::Proc,
     error::Result,
@@ -27,6 +28,7 @@ use std::{
     sync::{Arc, OnceLock},
     time::Duration,
 };
+use tracing::{debug, error};
 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");
@@ -52,7 +54,9 @@ pub struct ServerParams {
     pub preload: bool,
 
     pub request_timeout: Option<Duration>,
+    pub header_read_timeout: Duration,
     pub notify_watchers: Option<Vec<(String, Vec<Vec<String>>)>>,
+
     /// Worker params
     pub threads: u8,
     pub scheduler_threads: Option<u8>,
@@ -69,26 +73,39 @@ pub struct ServerParams {
     listener_info: Mutex<HashMap<String, i32>>,
 }
 
+pub struct SocketOpts {
+    pub reuse_address: bool,
+    pub reuse_port: bool,
+    pub listen_backlog: usize,
+    pub nodelay: bool,
+    pub recv_buffer_size: usize,
+}
+
 impl ServerParams {
     pub fn preload_ruby(self: &Arc<Self>) -> Result<()> {
         call_with_gvl(|ruby| -> Result<()> {
+            debug!("Preloading Ruby");
             if self
                 .scheduler_class
                 .as_ref()
                 .is_some_and(|t| t == "Itsi::Scheduler")
             {
+                debug!("Loading Itsi Scheduler");
                 ruby.require("itsi/scheduler")?;
             }
-            let middleware = MiddlewareSet::new(
-                self.middleware_loader
-                    .call::<_, Option<Value>>(())
-                    .inspect_err(|e| {
-                        if let Some(err_value) = e.value() {
-                            print_rb_backtrace(err_value);
-                        }
-                    })?
-                    .map(|mw| mw.into()),
-            )?;
+            let routes_raw = self
+                .middleware_loader
+                .call::<_, Option<Value>>(())
+                .inspect_err(|e| {
+                    eprintln!("Error loading middleware: {:?}", e);
+                    if let Some(err_value) = e.value() {
+                        print_rb_backtrace(err_value);
+                    }
+                })?
+                .map(|mw| mw.into());
+            debug!("Middleware routes returned");
+            let middleware = MiddlewareSet::new(routes_raw)?;
+            debug!("Middleware loaded");
             self.middleware.set(middleware).map_err(|_| {
                 magnus::Error::new(
                     magnus::exception::runtime_error(),
@@ -100,6 +117,11 @@ impl ServerParams {
         Ok(())
     }
 
+    pub async fn initialize_middleware(self: &Arc<Self>) -> Result<()> {
+        self.middleware.get().unwrap().initialize_layers().await?;
+        Ok(())
+    }
+
     fn from_rb_hash(rb_param_hash: RHash) -> Result<ServerParams> {
         let workers = rb_param_hash
             .fetch::<_, Option<u8>>("workers")?
@@ -134,6 +156,10 @@ impl ServerParams {
         let preload: bool = rb_param_hash.fetch("preload")?;
         let request_timeout: Option<u64> = rb_param_hash.fetch("request_timeout")?;
         let request_timeout = request_timeout.map(Duration::from_secs);
+        let header_read_timeout: Duration = rb_param_hash
+            .fetch::<_, Option<u64>>("header_read_timeout")?
+            .map(Duration::from_secs)
+            .unwrap_or(Duration::from_secs(1));
 
         let notify_watchers: Option<Vec<(String, Vec<Vec<String>>)>> =
             rb_param_hash.fetch("notify_watchers")?;
@@ -147,6 +173,23 @@ impl ServerParams {
         let log_level: Option<String> = rb_param_hash.fetch("log_level")?;
         let log_target: Option<String> = rb_param_hash.fetch("log_target")?;
         let log_format: Option<String> = rb_param_hash.fetch("log_format")?;
+        let log_target_filters: Option<Vec<String>> = rb_param_hash.fetch("log_target_filters")?;
+
+        let reuse_address: bool = rb_param_hash
+            .fetch::<_, Option<bool>>("reuse_address")?
+            .unwrap_or(true);
+        let reuse_port: bool = rb_param_hash
+            .fetch::<_, Option<bool>>("reuse_port")?
+            .unwrap_or(true);
+        let listen_backlog: usize = rb_param_hash
+            .fetch::<_, Option<usize>>("listen_backlog")?
+            .unwrap_or(1024);
+        let nodelay: bool = rb_param_hash
+            .fetch::<_, Option<bool>>("nodelay")?
+            .unwrap_or(true);
+        let recv_buffer_size: usize = rb_param_hash
+            .fetch::<_, Option<usize>>("recv_buffer_size")?
+            .unwrap_or(262_144);
 
         if let Some(level) = log_level {
             set_level(&level);
@@ -160,6 +203,22 @@ impl ServerParams {
             set_format(&format);
         }
 
+        if let Some(target_filters) = log_target_filters {
+            let target_filters = target_filters
+                .iter()
+                .filter_map(|filter| {
+                    let mut parts = filter.splitn(2, '=');
+                    if let (Some(target), Some(level_str)) = (parts.next(), parts.next()) {
+                        if let Ok(level) = level_str.parse::<tracing::Level>() {
+                            return Some((target, level));
+                        }
+                    }
+                    None
+                })
+                .collect::<Vec<(&str, tracing::Level)>>();
+            set_target_filters(target_filters);
+        }
+
         let binds: Option<Vec<String>> = rb_param_hash.fetch("binds")?;
         let binds = binds
             .unwrap_or_else(|| vec![DEFAULT_BIND.to_string()])
@@ -167,6 +226,13 @@ impl ServerParams {
             .map(|s| s.parse())
             .collect::<itsi_error::Result<Vec<Bind>>>()?;
 
+        let socket_opts = SocketOpts {
+            reuse_address,
+            reuse_port,
+            listen_backlog,
+            nodelay,
+            recv_buffer_size,
+        };
         let listeners = if let Some(preexisting_listeners) =
             rb_param_hash.delete::<_, Option<String>>("listeners")?
         {
@@ -183,9 +249,9 @@ impl ServerParams {
                 .cloned()
                 .map(|bind| {
                     if let Some(fd) = bind_to_fd_map.get(&bind.listener_address_string()) {
-                        Listener::inherit_fd(bind, *fd)
+                        Listener::inherit_fd(bind, *fd, &socket_opts)
                     } else {
-                        Listener::try_from(bind)
+                        Listener::build(bind, &socket_opts)
                     }
                 })
                 .collect::<std::result::Result<Vec<Listener>, _>>()?
@@ -195,7 +261,7 @@ impl ServerParams {
             binds
                 .iter()
                 .cloned()
-                .map(Listener::try_from)
+                .map(|b| Listener::build(b, &socket_opts))
                 .collect::<std::result::Result<Vec<Listener>, _>>()?
                 .into_iter()
                 .collect::<Vec<_>>()
@@ -220,6 +286,7 @@ impl ServerParams {
             hooks,
             preload,
             request_timeout,
+            header_read_timeout,
             notify_watchers,
             threads,
             scheduler_threads,
@@ -249,6 +316,7 @@ impl ItsiServerConfig {
             itsifile_path.as_ref(),
             itsi_config_proc.clone(),
         )?;
+
         cli_params.delete::<_, Value>(Symbol::new("listeners"))?;
 
         let watcher_fd = if let Some(watchers) = server_params.notify_watchers.clone() {
@@ -276,7 +344,6 @@ impl ItsiServerConfig {
                 self.itsi_config_proc.clone(),
             )
         })?;
-
         let is_single_mode = self.server_params.read().workers == 1;
 
         let requires_exec = if !is_single_mode && !server_params.preload {
@@ -305,10 +372,18 @@ impl ItsiServerConfig {
             .as_ref()
             .clone()
             .map(|hv| hv.clone().inner());
-        let rb_param_hash: RHash = ruby.get_inner_ref(&ITSI_SERVER_CONFIG).funcall(
-            *ID_BUILD_CONFIG,
-            (cli_params, itsifile_path.cloned(), inner),
-        )?;
+        let (rb_param_hash, errors): (RHash, Vec<String>) =
+            ruby.get_inner_ref(&ITSI_SERVER_CONFIG).funcall(
+                *ID_BUILD_CONFIG,
+                (cli_params, itsifile_path.cloned(), inner),
+            )?;
+        if !errors.is_empty() {
+            Self::print_config_errors(errors);
+            return Err(magnus::Error::new(
+                magnus::exception::standard_error(),
+                "Invalid server config",
+            ));
+        }
         Ok(Arc::new(ServerParams::from_rb_hash(rb_param_hash)?))
     }
 
@@ -322,6 +397,47 @@ impl ItsiServerConfig {
         Ok(())
     }
 
+    pub fn get_config_errors(&self) -> Option<Vec<String>> {
+        let rb_param_hash = call_with_gvl(|ruby| {
+            let inner = self
+                .itsi_config_proc
+                .as_ref()
+                .clone()
+                .map(|hv| hv.clone().inner());
+            let cli_params = self.cli_params.cloned();
+            let itsifile_path = self.itsifile_path.clone();
+
+            let (rb_param_hash, errors): (RHash, Vec<String>) = ruby
+                .get_inner_ref(&ITSI_SERVER_CONFIG)
+                .funcall(*ID_BUILD_CONFIG, (cli_params, itsifile_path, inner))
+                .unwrap();
+            if !errors.is_empty() {
+                return Err(errors);
+            }
+            Ok(rb_param_hash)
+        });
+        match rb_param_hash {
+            Ok(rb_param_hash) => match ServerParams::from_rb_hash(rb_param_hash) {
+                Ok(test_params) => {
+                    let params_arc = Arc::new(test_params);
+                    if let Err(err) = params_arc.clone().preload_ruby() {
+                        let err_val = call_with_gvl(|_| format!("{}", err));
+                        return Some(vec![err_val]);
+                    }
+                    if let Err(err) =
+                        block_on(params_arc.middleware.get().unwrap().initialize_layers())
+                    {
+                        let err_val = call_with_gvl(|_| format!("{}", err));
+                        return Some(vec![err_val]);
+                    }
+                    None
+                }
+                Err(err) => Some(vec![format!("{:?}", err)]),
+            },
+            Err(err) => Some(err),
+        }
+    }
+
     pub fn dup_fds(self: &Arc<Self>) -> Result<()> {
         let binding = self.server_params.read();
         let mut listener_info_guard = binding.listener_info.lock();
@@ -354,6 +470,21 @@ impl ItsiServerConfig {
         Ok(())
     }
 
+    pub fn print_config_errors(errors: Vec<String>) {
+        error!("Refusing to reload configuration due to fatal errors:");
+        for error in errors {
+            eprintln!("{}", error);
+        }
+    }
+
+    pub fn check_config(&self) -> bool {
+        if let Some(errors) = self.get_config_errors() {
+            Self::print_config_errors(errors);
+            return false;
+        }
+        true
+    }
+
     pub fn reload_exec(self: &Arc<Self>) -> Result<()> {
         let listener_json =
             serde_json::to_string(&self.server_params.read().listener_info.lock().clone())

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

@@ -72,6 +72,7 @@ impl ItsiServer {
             let strategy = self.build_strategy()?;
             if let Err(e) = strategy.clone().run() {
                 error!("Error running server: {}", e);
+                send_lifecycle_event(LifecycleEvent::Shutdown);
                 strategy.stop()?;
             }
             Ok(())

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

@@ -1,4 +1,5 @@
 use crate::prelude::*;
+use crate::ruby_types::itsi_server::itsi_server_config::SocketOpts;
 use crate::server::io_stream::IoStream;
 use crate::server::serve_strategy::single_mode::RunningPhase;
 
@@ -326,12 +327,12 @@ impl Listener {
         }
     }
 
-    pub fn inherit_fd(bind: Bind, fd: RawFd) -> Result<Self> {
+    pub fn inherit_fd(bind: Bind, fd: RawFd, socket_opts: &SocketOpts) -> Result<Self> {
         let bound = match bind.address {
             BindAddress::Ip(_) => match bind.protocol {
-                BindProtocol::Http => Listener::Tcp(revive_tcp_socket(fd)?),
+                BindProtocol::Http => Listener::Tcp(revive_tcp_socket(fd, socket_opts)?),
                 BindProtocol::Https => {
-                    let tcp_listener = revive_tcp_socket(fd)?;
+                    let tcp_listener = revive_tcp_socket(fd, socket_opts)?;
                     Listener::TcpTls((
                         tcp_listener,
                         bind.tls_config.unwrap().build_acceptor().unwrap(),
@@ -341,25 +342,25 @@ impl Listener {
             },
             BindAddress::UnixSocket(_) => match bind.tls_config {
                 Some(tls_config) => Listener::UnixTls((
-                    revive_unix_socket(fd)?,
+                    revive_unix_socket(fd, socket_opts)?,
                     tls_config.build_acceptor().unwrap(),
                 )),
-                None => Listener::Unix(revive_unix_socket(fd)?),
+                None => Listener::Unix(revive_unix_socket(fd, socket_opts)?),
             },
         };
         Ok(bound)
     }
 }
 
-impl TryFrom<Bind> for Listener {
-    type Error = itsi_error::ItsiError;
-
-    fn try_from(bind: Bind) -> std::result::Result<Self, Self::Error> {
+impl Listener {
+    pub fn build(bind: Bind, socket_opts: &SocketOpts) -> Result<Self> {
         let bound = match bind.address {
             BindAddress::Ip(addr) => match bind.protocol {
-                BindProtocol::Http => Listener::Tcp(connect_tcp_socket(addr, bind.port.unwrap())?),
+                BindProtocol::Http => {
+                    Listener::Tcp(connect_tcp_socket(addr, bind.port.unwrap(), socket_opts)?)
+                }
                 BindProtocol::Https => {
-                    let tcp_listener = connect_tcp_socket(addr, bind.port.unwrap())?;
+                    let tcp_listener = connect_tcp_socket(addr, bind.port.unwrap(), socket_opts)?;
                     Listener::TcpTls((
                         tcp_listener,
                         bind.tls_config.unwrap().build_acceptor().unwrap(),
@@ -369,56 +370,60 @@ impl TryFrom<Bind> for Listener {
             },
             BindAddress::UnixSocket(path) => match bind.tls_config {
                 Some(tls_config) => Listener::UnixTls((
-                    connect_unix_socket(&path)?,
+                    connect_unix_socket(&path, socket_opts)?,
                     tls_config.build_acceptor().unwrap(),
                 )),
-                None => Listener::Unix(connect_unix_socket(&path)?),
+                None => Listener::Unix(connect_unix_socket(&path, socket_opts)?),
             },
         };
         Ok(bound)
     }
 }
 
-fn revive_tcp_socket(fd: RawFd) -> Result<TcpListener> {
+fn revive_tcp_socket(fd: RawFd, socket_opts: &SocketOpts) -> Result<TcpListener> {
     let socket = unsafe { Socket::from_raw_fd(fd) };
-    socket.set_reuse_port(true).ok();
-    socket.set_reuse_address(true).ok();
+    socket.set_reuse_port(socket_opts.reuse_port).ok();
+    socket.set_reuse_address(socket_opts.reuse_address).ok();
     socket.set_nonblocking(true).ok();
-    socket.set_nodelay(true).ok();
-    socket.set_recv_buffer_size(262_144).ok();
+    socket.set_nodelay(socket_opts.nodelay).ok();
+    socket
+        .set_recv_buffer_size(socket_opts.recv_buffer_size)
+        .ok();
     socket.set_cloexec(true)?;
-    socket.listen(1024)?;
+    socket.listen(socket_opts.listen_backlog as i32)?;
     Ok(socket.into())
 }
 
-fn revive_unix_socket(fd: RawFd) -> Result<UnixListener> {
+fn revive_unix_socket(fd: RawFd, socket_opts: &SocketOpts) -> Result<UnixListener> {
     let socket = unsafe { Socket::from_raw_fd(fd) };
     socket.set_nonblocking(true).ok();
-    socket.listen(1024)?;
+    socket.listen(socket_opts.listen_backlog as i32)?;
     socket.set_cloexec(true)?;
 
     Ok(socket.into())
 }
 
-fn connect_tcp_socket(addr: IpAddr, port: u16) -> Result<TcpListener> {
+fn connect_tcp_socket(addr: IpAddr, port: u16, socket_opts: &SocketOpts) -> Result<TcpListener> {
     let domain = match addr {
         IpAddr::V4(_) => Domain::IPV4,
         IpAddr::V6(_) => Domain::IPV6,
     };
     let socket = Socket::new(domain, Type::STREAM, Some(Protocol::TCP))?;
     let socket_address: SocketAddr = SocketAddr::new(addr, port);
-    socket.set_reuse_address(true).ok();
-    socket.set_reuse_port(true).ok();
+    socket.set_reuse_address(socket_opts.reuse_address).ok();
+    socket.set_reuse_port(socket_opts.reuse_port).ok();
     socket.set_nonblocking(true).ok();
-    socket.set_nodelay(true).ok();
-    socket.set_recv_buffer_size(262_144).ok();
+    socket.set_nodelay(socket_opts.nodelay).ok();
+    socket
+        .set_recv_buffer_size(socket_opts.recv_buffer_size)
+        .ok();
     socket.set_only_v6(false).ok();
     socket.bind(&socket_address.into())?;
-    socket.listen(1024)?;
+    socket.listen(socket_opts.listen_backlog as i32)?;
     Ok(socket.into())
 }
 
-fn connect_unix_socket(path: &PathBuf) -> Result<UnixListener> {
+fn connect_unix_socket(path: &PathBuf, socket_opts: &SocketOpts) -> Result<UnixListener> {
     let _ = std::fs::remove_file(path);
     let socket = Socket::new(Domain::UNIX, Type::STREAM, None)?;
     socket.set_nonblocking(true).ok();
@@ -426,7 +431,7 @@ fn connect_unix_socket(path: &PathBuf) -> Result<UnixListener> {
     let socket_address = socket2::SockAddr::unix(path)?;
 
     socket.bind(&socket_address)?;
-    socket.listen(1024)?;
+    socket.listen(socket_opts.listen_backlog as i32)?;
 
     Ok(socket.into())
 }

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

@@ -1,11 +1,11 @@
 use async_trait::async_trait;
 use fs2::FileExt;
+use itsi_acme::caches::DirCache;
+use itsi_acme::{AccountCache, CertCache};
 use parking_lot::Mutex;
 use std::fs::{self, OpenOptions};
 use std::io::Error as IoError;
 use std::path::{Path, PathBuf};
-use tokio_rustls_acme::caches::DirCache;
-use tokio_rustls_acme::{AccountCache, CertCache};
 
 use crate::env::ITSI_ACME_LOCK_FILE_NAME;
 

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

@@ -1,4 +1,5 @@
 use base64::{engine::general_purpose, Engine as _};
+use itsi_acme::{AcmeAcceptor, AcmeConfig, AcmeState};
 use itsi_error::Result;
 use itsi_tracing::info;
 use locked_dir_cache::LockedDirCache;
@@ -18,7 +19,6 @@ use std::{
 };
 use tokio::sync::Mutex;
 use tokio_rustls::{rustls::ServerConfig, TlsAcceptor};
-use tokio_rustls_acme::{AcmeAcceptor, AcmeConfig, AcmeState};
 
 use crate::env::{
     ITSI_ACME_CACHE_DIR, ITSI_ACME_CA_PEM_PATH, ITSI_ACME_CONTACT_EMAIL, ITSI_ACME_DIRECTORY_URL,

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

@@ -8,30 +8,31 @@ use super::middlewares::*;
 use async_trait::async_trait;
 use either::Either;
 use magnus::error::Result;
-use std::cmp::Ordering;
+use std::{cmp::Ordering, sync::Arc};
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Middleware {
-    AllowList(AllowList),
-    AuthAPIKey(AuthAPIKey),
-    AuthBasic(AuthBasic),
-    AuthJwt(Box<AuthJwt>),
-    CacheControl(CacheControl),
-    Compression(Compression),
-    Cors(Box<Cors>),
-    DenyList(DenyList),
-    ETag(ETag),
-    IntrusionProtection(IntrusionProtection),
-    LogRequests(LogRequests),
-    MaxBody(MaxBody),
-    Proxy(Proxy),
-    RateLimit(RateLimit),
-    Redirect(Redirect),
-    RequestHeaders(RequestHeaders),
-    ResponseHeaders(ResponseHeaders),
-    RubyApp(RubyApp),
-    StaticAssets(StaticAssets),
-    StaticResponse(StaticResponse),
+    AllowList(Arc<AllowList>),
+    AuthAPIKey(Arc<AuthAPIKey>),
+    AuthBasic(Arc<AuthBasic>),
+    AuthJwt(Arc<AuthJwt>),
+    CacheControl(Arc<CacheControl>),
+    Compression(Arc<Compression>),
+    Cors(Arc<Cors>),
+    Csp(Arc<Csp>),
+    DenyList(Arc<DenyList>),
+    ETag(Arc<ETag>),
+    IntrusionProtection(Arc<IntrusionProtection>),
+    LogRequests(Arc<LogRequests>),
+    MaxBody(Arc<MaxBody>),
+    Proxy(Arc<Proxy>),
+    RateLimit(Arc<RateLimit>),
+    Redirect(Arc<Redirect>),
+    RequestHeaders(Arc<RequestHeaders>),
+    ResponseHeaders(Arc<ResponseHeaders>),
+    RubyApp(Arc<RubyApp>),
+    StaticAssets(Arc<StaticAssets>),
+    StaticResponse(Arc<StaticResponse>),
 }
 
 #[async_trait]
@@ -51,6 +52,7 @@ impl MiddlewareLayer for Middleware {
             Middleware::ResponseHeaders(filter) => filter.initialize().await,
             Middleware::CacheControl(filter) => filter.initialize().await,
             Middleware::Cors(filter) => filter.initialize().await,
+            Middleware::Csp(filter) => filter.initialize().await,
             Middleware::ETag(filter) => filter.initialize().await,
             Middleware::StaticAssets(filter) => filter.initialize().await,
             Middleware::StaticResponse(filter) => filter.initialize().await,
@@ -80,6 +82,7 @@ impl MiddlewareLayer for Middleware {
             Middleware::RateLimit(filter) => filter.before(req, context).await,
             Middleware::CacheControl(filter) => filter.before(req, context).await,
             Middleware::Cors(filter) => filter.before(req, context).await,
+            Middleware::Csp(filter) => filter.before(req, context).await,
             Middleware::ETag(filter) => filter.before(req, context).await,
             Middleware::StaticAssets(filter) => filter.before(req, context).await,
             Middleware::StaticResponse(filter) => filter.before(req, context).await,
@@ -104,6 +107,7 @@ impl MiddlewareLayer for Middleware {
             Middleware::RequestHeaders(filter) => filter.after(res, context).await,
             Middleware::ResponseHeaders(filter) => filter.after(res, context).await,
             Middleware::CacheControl(filter) => filter.after(res, context).await,
+            Middleware::Csp(filter) => filter.after(res, context).await,
             Middleware::Cors(filter) => filter.after(res, context).await,
             Middleware::ETag(filter) => filter.after(res, context).await,
             Middleware::StaticAssets(filter) => filter.after(res, context).await,
@@ -134,12 +138,13 @@ impl Middleware {
             Middleware::AuthAPIKey(_) => 11,
             Middleware::RateLimit(_) => 12,
             Middleware::ETag(_) => 13,
-            Middleware::Compression(_) => 14,
-            Middleware::Proxy(_) => 15,
-            Middleware::Cors(_) => 16,
-            Middleware::StaticResponse(_) => 17,
-            Middleware::StaticAssets(_) => 18,
-            Middleware::RubyApp(_) => 19,
+            Middleware::Csp(_) => 14,
+            Middleware::Compression(_) => 15,
+            Middleware::Proxy(_) => 16,
+            Middleware::Cors(_) => 17,
+            Middleware::StaticResponse(_) => 18,
+            Middleware::StaticAssets(_) => 19,
+            Middleware::RubyApp(_) => 20,
         }
     }
 }