itsi-server 0.2.15 → 0.2.17

data/ext/itsi_server/src/services/rate_limiter.rs

@@ -1,4 +1,5 @@
 use async_trait::async_trait;
+use parking_lot::{Mutex, RwLock};
 use rand::Rng;
 use redis::aio::ConnectionManager;
 use redis::{Client, RedisError, Script};
@@ -6,9 +7,9 @@ use serde::Deserialize;
 use std::any::Any;
 use std::collections::{HashMap, HashSet};
 use std::result::Result;
-use std::sync::{Arc, LazyLock, Mutex};
+use std::sync::{Arc, LazyLock};
 use std::time::{Duration, Instant};
-use tokio::sync::{Mutex as AsyncMutex, RwLock};
+use tokio::sync::Mutex as AsyncMutex;
 use tokio::time::timeout;
 use tracing::warn;
 use url::Url;
@@ -242,10 +243,10 @@ impl InMemoryRateLimiter {
     /// Cleans up expired entries
     async fn cleanup(&self) {
         // Try to get the write lock, but fail open if we can't
-        if let Ok(mut entries) = self.entries.try_write() {
-            let now = Instant::now();
-            entries.retain(|_, entry| entry.expires_at > now);
-        }
+        let now = Instant::now();
+        self.entries
+            .write()
+            .retain(|_, entry| entry.expires_at > now);
     }
 
     /// Bans an IP address for the specified duration
@@ -258,12 +259,7 @@ impl InMemoryRateLimiter {
         let now = Instant::now();
         let ban_key = format!("ban:ip:{}", ip);
 
-        let mut entries = self.entries.try_write().map_err(|e| {
-            tracing::error!("Failed to acquire write lock: {}", e);
-            RateLimitError::LockError
-        })?;
-
-        entries.insert(
+        self.entries.write().insert(
             ban_key,
             RateLimitEntry {
                 count: 1, // Use count=1 to indicate banned
@@ -279,12 +275,7 @@ impl InMemoryRateLimiter {
         let now = Instant::now();
         let ban_key = format!("ban:ip:{}", ip);
 
-        let entries = self.entries.try_read().map_err(|e| {
-            tracing::error!("Failed to acquire read lock: {}", e);
-            RateLimitError::LockError
-        })?;
-
-        if let Some(entry) = entries.get(&ban_key) {
+        if let Some(entry) = self.entries.read().get(&ban_key) {
             if entry.expires_at > now {
                 // IP is banned, return a generic reason since we don't store reasons
                 return Ok(Some("IP address banned".to_string()));
@@ -310,7 +301,7 @@ impl RateLimiter for InMemoryRateLimiter {
 
         let now = Instant::now();
 
-        let mut entries = self.entries.write().await;
+        let mut entries = self.entries.write();
 
         let entry = entries
             .entry(key.to_string())
@@ -436,7 +427,7 @@ impl RateLimiterStore {
     ) -> Result<Arc<RedisRateLimiter>, RateLimitError> {
         // First check if this URL is known to fail
         {
-            let failed_urls = self.failed_urls.lock().unwrap_or_else(|e| e.into_inner());
+            let failed_urls = self.failed_urls.lock();
             if failed_urls.contains(connection_url) {
                 return Err(RateLimitError::ConnectionTimeout);
             }
@@ -444,10 +435,7 @@ impl RateLimiterStore {
 
         // Then check if we already have a limiter for this URL
         {
-            let limiters = self
-                .redis_limiters
-                .lock()
-                .unwrap_or_else(|e| e.into_inner());
+            let limiters = self.redis_limiters.lock();
             if let Some(limiter) = limiters.get(connection_url) {
                 return Ok(limiter.clone());
             }
@@ -455,7 +443,7 @@ impl RateLimiterStore {
 
         // Get a dedicated mutex for this URL or create a new one if it doesn't exist
         let url_mutex = {
-            let mut locks = CONNECTION_LOCKS.lock().unwrap_or_else(|e| e.into_inner());
+            let mut locks = CONNECTION_LOCKS.lock();
 
             // Get or create the mutex for this URL
             locks
@@ -476,10 +464,7 @@ impl RateLimiterStore {
 
         // Check again if another thread created the limiter while we were waiting
         {
-            let limiters = self
-                .redis_limiters
-                .lock()
-                .unwrap_or_else(|e| e.into_inner());
+            let limiters = self.redis_limiters.lock();
             if let Some(limiter) = limiters.get(connection_url) {
                 return Ok(limiter.clone());
             }
@@ -492,10 +477,7 @@ impl RateLimiterStore {
                 let limiter = Arc::new(limiter);
 
                 // Store it for future use
-                let mut limiters = self
-                    .redis_limiters
-                    .lock()
-                    .unwrap_or_else(|e| e.into_inner());
+                let mut limiters = self.redis_limiters.lock();
                 limiters.insert(connection_url.to_string(), limiter.clone());
 
                 Ok(limiter)
@@ -503,7 +485,7 @@ impl RateLimiterStore {
             Err(e) => {
                 tracing::error!("Failed to initialize Redis rate limiter: {}", e);
                 // Cache the failure
-                let mut failed_urls = self.failed_urls.lock().unwrap_or_else(|e| e.into_inner());
+                let mut failed_urls = self.failed_urls.lock();
                 failed_urls.insert(connection_url.to_string());
                 Err(e)
             }

data/ext/itsi_server/src/services/static_file_server.rs

@@ -2,7 +2,7 @@ use crate::{
     default_responses::NOT_FOUND_RESPONSE,
     prelude::*,
     server::{
-        http_message_types::{HttpRequest, HttpResponse, RequestExt, ResponseFormat},
+        http_message_types::{HttpBody, HttpRequest, HttpResponse, RequestExt, ResponseFormat},
         middleware_stack::ErrorResponse,
         redirect_type::RedirectType,
     },
@@ -16,10 +16,9 @@ use http::{
     },
     HeaderName, HeaderValue, Response, StatusCode,
 };
-use http_body_util::{combinators::BoxBody, Full};
 use itsi_error::Result;
 use parking_lot::{Mutex, RwLock};
-use percent_encoding::{percent_decode_str, utf8_percent_encode, NON_ALPHANUMERIC};
+use percent_encoding::percent_decode_str;
 use quick_cache::sync::Cache;
 use serde::Deserialize;
 use serde_json::json;
@@ -28,7 +27,6 @@ use std::{
     borrow::Cow,
     cmp::Ordering,
     collections::HashMap,
-    convert::Infallible,
     fs::Metadata,
     ops::Deref,
     path::{Path, PathBuf},
@@ -175,7 +173,7 @@ impl CacheEntry {
             let mut hasher = Sha256::new();
             hasher.update(&bytes);
             let result = hasher.finalize();
-            general_purpose::STANDARD.encode(result)
+            general_purpose::STANDARD.encode(&result[..16])
         };
         let headers_ct = get_mime_type(&path);
         let headers_etag = format!(r#"W/"{etag}""#).parse().unwrap();
@@ -279,7 +277,7 @@ impl StaticFileServer {
         supported_encodings: &[HeaderValue],
     ) -> Option<HttpResponse> {
         let accept: ResponseFormat = request.accept().into();
-        let resolved = self.resolve(path, abs_path, accept.clone()).await;
+        let resolved = self.resolve(path, abs_path, accept).await;
 
         Some(match resolved {
             Ok(ResolvedAsset {
@@ -324,7 +322,7 @@ impl StaticFileServer {
             }) => Response::builder()
                 .status(StatusCode::MOVED_PERMANENTLY)
                 .header(header::LOCATION, redirect_to)
-                .body(BoxBody::new(Full::new(Bytes::new())))
+                .body(HttpBody::empty())
                 .unwrap(),
             Err(not_found_behavior) => match not_found_behavior {
                 NotFoundBehavior::Error(error_response) => {
@@ -340,7 +338,7 @@ impl StaticFileServer {
                 NotFoundBehavior::Redirect(redirect) => Response::builder()
                     .status(redirect.r#type.status_code())
                     .header(header::LOCATION, redirect.to)
-                    .body(BoxBody::new(Full::new(Bytes::new())))
+                    .body(HttpBody::empty())
                     .unwrap(),
             },
         })
@@ -407,7 +405,7 @@ impl StaticFileServer {
 
         Response::builder()
             .status(StatusCode::NOT_FOUND)
-            .body(BoxBody::new(Full::new(Bytes::new())))
+            .body(HttpBody::empty())
             .unwrap()
     }
 
@@ -648,15 +646,8 @@ impl StaticFileServer {
         Err(nf)
     }
 
-    async fn stream_file_range(
-        &self,
-        path: PathBuf,
-        start: u64,
-        end: u64,
-    ) -> Option<BoxBody<Bytes, Infallible>> {
+    async fn stream_file_range(&self, path: PathBuf, start: u64, end: u64) -> Option<HttpBody> {
         use futures::TryStreamExt;
-        use http_body_util::StreamBody;
-        use hyper::body::Frame;
         use tokio::io::AsyncSeekExt;
         use tokio_util::io::ReaderStream;
 
@@ -687,32 +678,25 @@ impl StaticFileServer {
         let range_length = end - start + 1;
         let limited_reader = tokio::io::AsyncReadExt::take(file, range_length);
         let path_clone = path.clone();
-        let stream = ReaderStream::with_capacity(limited_reader, 64 * 1024)
-            .map_ok(Frame::data)
-            .map_err(move |e| {
-                warn!("Error streaming file {}: {}", path_clone.display(), e);
-                unreachable!("We handle IO errors above")
-            });
-
-        Some(BoxBody::new(StreamBody::new(stream)))
+        let stream = ReaderStream::with_capacity(limited_reader, 64 * 1024).map_err(move |e| {
+            warn!("Error streaming file {}: {}", path_clone.display(), e);
+            unreachable!("We handle IO errors above")
+        });
+        Some(HttpBody::stream(stream))
     }
 
-    async fn stream_file(&self, path: PathBuf) -> Option<BoxBody<Bytes, Infallible>> {
+    async fn stream_file(&self, path: PathBuf) -> Option<HttpBody> {
         use futures::TryStreamExt;
-        use http_body_util::StreamBody;
-        use hyper::body::Frame;
         use tokio_util::io::ReaderStream;
 
         match File::open(&path).await {
             Ok(file) => {
                 let path_clone = path.clone();
-                let stream = ReaderStream::with_capacity(file, 64 * 1024)
-                    .map_ok(Frame::data)
-                    .map_err(move |e| {
-                        warn!("Error streaming file {}: {}", path_clone.display(), e);
-                        unreachable!("We handle IO errors above")
-                    });
-                Some(BoxBody::new(StreamBody::new(stream)))
+                let stream = ReaderStream::with_capacity(file, 64 * 1024).map_err(move |e| {
+                    warn!("Error streaming file {}: {}", path_clone.display(), e);
+                    unreachable!("We handle IO errors above")
+                });
+                Some(HttpBody::stream(stream))
             }
             Err(e) => {
                 warn!(
@@ -749,7 +733,7 @@ impl StaticFileServer {
             return Response::builder()
                 .status(StatusCode::RANGE_NOT_SATISFIABLE)
                 .header("Content-Range", format!("bytes */{}", content_length))
-                .body(BoxBody::new(Full::new(Bytes::new())))
+                .body(HttpBody::empty())
                 .unwrap();
         }
 
@@ -795,7 +779,7 @@ impl StaticFileServer {
                 builder = builder.header("Content-Range", range);
             }
 
-            return builder.body(BoxBody::new(Full::new(Bytes::new()))).unwrap();
+            return builder.body(HttpBody::empty()).unwrap();
         }
 
         // For GET requests, prepare the actual content
@@ -829,10 +813,7 @@ impl StaticFileServer {
         }
     }
 
-    fn serve_cached_content(
-        &self,
-        serve_cache_args: ServeCacheArgs,
-    ) -> http::Response<BoxBody<Bytes, Infallible>> {
+    fn serve_cached_content(&self, serve_cache_args: ServeCacheArgs) -> HttpResponse {
         let ServeCacheArgs(
             cache_entry,
             start,
@@ -855,7 +836,7 @@ impl StaticFileServer {
             return Response::builder()
                 .status(StatusCode::RANGE_NOT_SATISFIABLE)
                 .header("Content-Range", format!("bytes */{}", content_length))
-                .body(BoxBody::new(Full::new(Bytes::new())))
+                .body(HttpBody::empty())
                 .unwrap();
         }
 
@@ -904,7 +885,7 @@ impl StaticFileServer {
                 builder = builder.header("Content-Range", range);
             }
 
-            return builder.body(BoxBody::new(Full::new(Bytes::new()))).unwrap();
+            return builder.body(HttpBody::empty()).unwrap();
         }
 
         if is_range_request {
@@ -920,7 +901,7 @@ impl StaticFileServer {
                 cache_entry.last_modified_http_date.clone(),
                 content_range,
                 &self.headers,
-                BoxBody::new(Full::new(range_bytes)),
+                HttpBody::full(range_bytes),
             )
         } else {
             // Return the full content
@@ -987,15 +968,15 @@ fn format_http_date_header(time: SystemTime) -> HeaderValue {
         .unwrap()
 }
 
-fn build_ok_body(bytes: Arc<Bytes>) -> BoxBody<Bytes, Infallible> {
-    BoxBody::new(Full::new(bytes.as_ref().clone()))
+fn build_ok_body(bytes: Arc<Bytes>) -> HttpBody {
+    HttpBody::full(bytes.as_ref().clone())
 }
 
 // Helper function to handle not modified responses
-fn build_not_modified_response() -> http::Response<BoxBody<Bytes, Infallible>> {
+fn build_not_modified_response() -> HttpResponse {
     Response::builder()
         .status(StatusCode::NOT_MODIFIED)
-        .body(BoxBody::new(Full::new(Bytes::new())))
+        .body(HttpBody::empty())
         .unwrap()
 }
 
@@ -1009,8 +990,8 @@ fn build_file_response(
     last_modified_http_date: HeaderValue,
     range_header: Option<String>,
     headers: &Option<HashMap<String, String>>,
-    body: BoxBody<Bytes, Infallible>,
-) -> http::Response<BoxBody<Bytes, Infallible>> {
+    body: HttpBody,
+) -> HttpResponse {
     let mut response = Response::new(body);
 
     *response.status_mut() = status;
@@ -1188,7 +1169,6 @@ async fn generate_directory_listing(
 
             // Generate JSON entries for directories.
             for (name, metadata) in dirs {
-                let encoded = utf8_percent_encode(&name, NON_ALPHANUMERIC).to_string();
                 let modified = metadata
                     .modified()
                     .ok()
@@ -1201,7 +1181,7 @@ async fn generate_directory_listing(
 
                 items.push(json!({
                     "name": format!("{}/", name),
-                    "path": format!("{}/", encoded),
+                    "path": format!("{}/", name),
                     "is_dir": true,
                     "size": null,
                     "modified": modified,
@@ -1210,7 +1190,6 @@ async fn generate_directory_listing(
 
             // Generate JSON entries for files.
             for (name, metadata) in files {
-                let encoded = utf8_percent_encode(&name, NON_ALPHANUMERIC).to_string();
                 let file_size = metadata.len();
                 let formatted_size = if file_size < 1024 {
                     format!("{} B", file_size)
@@ -1234,7 +1213,7 @@ async fn generate_directory_listing(
 
                 items.push(json!({
                     "name": name,
-                    "path": encoded,
+                    "path": name,
                     "is_dir": false,
                     "size": formatted_size,
                     "modified": modified_str,
@@ -1341,11 +1320,9 @@ async fn generate_directory_listing(
 
             // Generate rows for directories.
             for (name, metadata) in dirs {
-                let encoded = utf8_percent_encode(&name, NON_ALPHANUMERIC).to_string();
-
                 rows.push_str(&format!(
             r#"<tr><td><a href="{0}/">{1}/</a></td><td class="size">-</td><td class="date">{2}</td></tr>"#,
-            encoded,
+            name,
             name,
             metadata.modified().ok().map(|m| DateTime::<Utc>::from(m).format("%Y-%m-%d %H:%M:%S").to_string())
                 .unwrap_or_else(|| "-".to_string())
@@ -1355,8 +1332,6 @@ async fn generate_directory_listing(
 
             // Generate rows for files.
             for (name, metadata) in files {
-                let encoded = utf8_percent_encode(&name, NON_ALPHANUMERIC).to_string();
-
                 let file_size = metadata.len();
                 let formatted_size = if file_size < 1024 {
                     format!("{} B", file_size)
@@ -1380,7 +1355,7 @@ async fn generate_directory_listing(
 
                 rows.push_str(&format!(
             r#"<tr><td><a href="{0}">{1}</a></td><td class="size">{2}</td><td class="date">{3}</td></tr>"#,
-            encoded, name, formatted_size, modified_str
+            name, name, formatted_size, modified_str
         ));
                 rows.push('\n');
             }

data/lib/itsi/http_request.rb

@@ -14,50 +14,35 @@ module Itsi
     EMPTY_IO = StringIO.new("").tap { |io| io.set_encoding(Encoding::ASCII_8BIT) }
 
     RACK_HEADER_MAP = StandardHeaders::ALL.map do |header|
-      rack_form = if header == "content-type"
-                    "CONTENT_TYPE"
-                  elsif header == "content-length"
-                    "CONTENT_LENGTH"
-                  else
-                    "HTTP_#{header.upcase.gsub(/-/, "_")}"
-                  end
+      rack_form = \
+        if header == "content-type"
+          "CONTENT_TYPE"
+        elsif header == "content-length"
+          "CONTENT_LENGTH"
+        else
+          "HTTP_#{header.upcase.gsub(/-/, "_")}"
+        end
       [header, rack_form]
-    end.to_h.tap do |hm|
-      hm.default_proc = proc { |_, key| "HTTP_#{key.upcase.gsub(/-/, "_")}" }
-    end
+    end.to_h
 
-    RACK_ENV_TEMPLATE = {
-      "SERVER_SOFTWARE" => "Itsi",
-      "rack.errors" => $stderr,
-      "rack.multithread" => true,
-      "rack.multiprocess" => true,
-      "rack.run_once" => false,
-      "rack.hijack?" => true,
-      "rack.multipart.buffer_size" => 16_384,
-      "SCRIPT_NAME" => "",
-      "REQUEST_METHOD" => "",
-      "PATH_INFO" => "",
-      "REQUEST_PATH" => "",
-      "QUERY_STRING" => "",
-      "REMOTE_ADDR" => "",
-      "SERVER_PORT" => "",
-      "SERVER_NAME" => "",
-      "SERVER_PROTOCOL" => "",
-      "HTTP_HOST" => "",
-      "HTTP_VERSION" => "",
-      "itsi.request" => "",
-      "itsi.response" => "",
-      "rack.version" => nil,
-      "rack.url_scheme" => "",
-      "rack.input" => "",
-      "rack.hijack" => ""
-    }.freeze
+    RACK_HEADER_MAP.default_proc = proc { |_, key| "HTTP_#{key.upcase.gsub(/-/, "_")}" }
+
+    HTTP_09 = "HTTP/0.9"
+    HTTP_09_ARR = ["HTTP/0.9"].freeze
+    HTTP_10 = "HTTP/1.0"
+    HTTP_10_ARR = ["HTTP/1.0"].freeze
+    HTTP_11 = "HTTP/1.1"
+    HTTP_11_ARR = ["HTTP/1.1"].freeze
+    HTTP_20 = "HTTP/2.0"
+    HTTP_20_ARR = ["HTTP/2.0"].freeze
+    HTTP_30 = "HTTP/3.0"
+    HTTP_30_ARR = ["HTTP/3.0"].freeze
 
     def to_rack_env
       path = self.path
       host = self.host
       version = self.version
-      env = RACK_ENV_TEMPLATE.dup
+      env = RackEnvPool.checkout
       env["SCRIPT_NAME"] = script_name
       env["REQUEST_METHOD"] = request_method
       env["REQUEST_PATH"] = env["PATH_INFO"] = path
@@ -68,11 +53,18 @@ module Itsi
       env["HTTP_VERSION"] = env["SERVER_PROTOCOL"] = version
       env["itsi.request"] = self
       env["itsi.response"] = response
-      env["rack.version"] = [version]
+      env["rack.version"] = \
+        case version
+        when HTTP_09 then HTTP_09_ARR
+        when HTTP_10 then HTTP_10_ARR
+        when HTTP_11 then HTTP_11_ARR
+        when HTTP_20 then HTTP_20_ARR
+        when HTTP_30 then HTTP_30_ARR
+        end
       env["rack.url_scheme"] = scheme
       env["rack.input"] = build_input_io
       env["rack.hijack"] = method(:hijack)
-      headers.each do |(k, v)|
+      each_header do |k, v|
         env[case k
             when "content-type" then "CONTENT_TYPE"
             when "content-length" then "CONTENT_LENGTH"

data/lib/itsi/http_response.rb

@@ -16,6 +16,7 @@ module Itsi
       body = body.to_s unless body.is_a?(String)
 
       if headers
+        reserve_headers(headers.size)
         headers.each do |key, value|
           if value.is_a?(Array)
             value.each { |v| add_header(key, v) }
@@ -40,5 +41,9 @@ module Itsi
         close
       end
     end
+
+    def flush
+      # No-op. Our Rust server performs stream coalescing and automatically flushes on a tight interval.
+    end
   end
 end

data/lib/itsi/rack_env_pool.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Itsi
+  module RackEnvPool
+
+    RACK_ENV_TEMPLATE = {
+      "SERVER_SOFTWARE" => "Itsi",
+      "rack.errors" => $stderr,
+      "rack.multithread" => true,
+      "rack.multiprocess" => true,
+      "rack.run_once" => false,
+      "rack.hijack?" => true,
+      "rack.multipart.buffer_size" => 16_384,
+      "SCRIPT_NAME" => "",
+      "REQUEST_METHOD" => "",
+      "PATH_INFO" => "",
+      "REQUEST_PATH" => "",
+      "QUERY_STRING" => "",
+      "REMOTE_ADDR" => "",
+      "SERVER_PORT" => "",
+      "SERVER_NAME" => "",
+      "SERVER_PROTOCOL" => "",
+      "HTTP_HOST" => "",
+      "HTTP_VERSION" => "",
+      "itsi.request" => "",
+      "itsi.response" => "",
+      "rack.version" => nil,
+      "rack.url_scheme" => "",
+      "rack.input" => "",
+      "rack.hijack" => ""
+    }.freeze
+
+    POOL = []
+
+    def self.checkout # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+      POOL.pop&.tap do |recycled|
+        recycled.keys.each do |key|
+          case key
+          when "SERVER_SOFTWARE" then recycled[key] = "Itsi"
+          when "rack.errors" then recycled[key] = $stderr
+          when "rack.multithread", "rack.multiprocess", "rack.hijack?" then recycled[key] = true
+          when "rack.run_once" then recycled[key] = false
+          when "rack.multipart.buffer_size" then recycled[key] = 16_384
+          when "SCRIPT_NAME", "REQUEST_METHOD", "PATH_INFO", "REQUEST_PATH", "QUERY_STRING", "REMOTE_ADDR",
+               "SERVER_PORT", "SERVER_NAME", "SERVER_PROTOCOL", "HTTP_HOST", "HTTP_VERSION", "itsi.request",
+               "itsi.response", "rack.version", "rack.url_scheme", "rack.input", "rack.hijack"
+            nil
+          else recycled.delete(key)
+          end
+        end
+      end || RACK_ENV_TEMPLATE.dup
+    end
+
+    def self.checkin(env)
+      POOL << env
+    end
+  end
+
+end

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

@@ -97,14 +97,13 @@ module Itsi
           if !self.class.ancestors.include?(Middleware) && !location.parent.nil?
             raise "#{opt_name} must be set at the top level"
           end
-
           @location = location
           @params = case schema
                     when TypedStruct::Validation
                       schema.validate!(params)
                     when Array
                       default, validation = schema
-                      params ? validation.validate!(params) : default
+                      !params.nil? ? validation.validate!(params) : default
                     when nil
                       nil
                     else

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

@@ -55,8 +55,9 @@ module Itsi
             nested_locations: [],
             middleware_loader: lambda do
               @options[:nested_locations].each(&:call)
-              @middleware[:app] ||= {}
-              @middleware[:app][:app_proc] = @middleware[:app]&.[](:preloader)&.call || DEFAULT_APP[]
+              if !(@middleware[:app] || @middleware[:static_assets])
+                @middleware[:app] = { app_proc: DEFAULT_APP[]}
+              end
               [flatten_routes, Config.errors_to_error_lines(errors)]
             end
           }
@@ -74,7 +75,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, caller[1]]
+            @errors << [e, e.backtrace.find{|r| !(r =~ /server\/config/) }]
           end
         end
 
@@ -85,7 +86,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, caller[1]]
+            @errors << [e, e.backtrace.find{|r| !(r =~ /server\/config/) }]
           end
         end
 

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

@@ -13,8 +13,7 @@ ETags are useful for optimizing client-side caching, conditional GETs, and reduc
 etag \
   type: "strong",
   algorithm: "sha256",
-  min_body_size: 0,
-  handle_if_none_match: true
+  min_body_size: 0
 ```
 
 ## ETag Applied to a sub-location
@@ -23,8 +22,7 @@ location "/assets" do
   etag \
     type: "weak",
     algorithm: "md5",
-    min_body_size: 1024,
-    handle_if_none_match: true
+    min_body_size: 1024
 end
 ```
 
@@ -40,12 +38,10 @@ end
 
 - **min_body_size**: Minimum response body size (in bytes) required before an ETag is generated. Use this to skip ETags for small or trivial responses.
 
-- **handle_if_none_match**: When `true`, incoming requests with a matching `If-None-Match` header will receive a `304 Not Modified` response (instead of a full body), if the ETag matches the computed value.
-
 ## How It Works
 
 ### Before the Response
-If `handle_if_none_match` is enabled and the request includes an `If-None-Match` header, the value is stored in the request context for comparison later.
+If  the request includes an `If-None-Match` header, the value is stored in the request context for comparison later.
 
 ### After the Response