itsi 0.2.15 → 0.2.17

data/gems/server/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/gems/server/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/gems/server/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/gems/server/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
 

data/gems/server/lib/itsi/server/config/middleware/etag.rb

@@ -7,8 +7,7 @@ module Itsi
         etag \\
           type: ${1|"strong","weak"|},
           algorithm: ${2|"sha256","md5"|},
-          min_body_size: ${3|0,1024|},
-          handle_if_none_match: ${4|true,false|}
+          min_body_size: ${3|0,1024|}
         SNIPPET
 
         detail "Enables ETag generation for the server."
@@ -17,8 +16,7 @@ module Itsi
           {
             type: (Enum(["strong", "weak"]) & Required()).default("strong"),
             algorithm: (Enum(["sha256", "md5"]) & Required()).default("sha256"),
-            min_body_size: Range(0...1024 ** 3).default(0),
-            handle_if_none_match: Bool().default(true)
+            min_body_size: Range(0...1024 ** 3).default(0)
           }
         end
       end

data/gems/server/lib/itsi/server/config/middleware/proxy.rb

@@ -7,7 +7,7 @@ module Itsi
             to: "${1:http://backend.example.com{path_and_query}",
             backends: [${2:"127.0.0.1:3001", "127.0.0.1:3002"}],
             backend_priority: ${3|"round_robin","ordered","random"|},
-            headers: { ${4| "X-Forwarded-For" => { rewrite: "{addr}" },|} },
+            headers: { ${4| "X-Forwarded-For" =>  "{addr}"|} },
             verify_ssl: ${5|true,false|},
             timeout: ${6|30,60|},
             tls_sni: ${7|true,false|},

data/gems/server/lib/itsi/server/config/middleware/rackup_file.rb

@@ -24,12 +24,12 @@ module Itsi
           super(location, params)
           raise "Rackup file must be a string" unless app.is_a?(String)
 
-          @app = Itsi::Server::RackInterface.for(app)
+          @app = app
         end
 
         def build!
           app_args = {
-            preloader: -> { @app },
+            preloader: -> { Itsi::Server::RackInterface.for(@app) },
             sendfile: @params[:sendfile],
             nonblocking: @params[:nonblocking],
             script_name: @params[:script_name],

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

@@ -14,11 +14,15 @@ module Itsi
         end
 
         def build!
+          return if @auto_reloading
+          src = caller.find{|l| !(l =~ /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
                 if ENV["BUNDLE_BIN_PATH"]
                   watch "#{file}.rb", [%w[bundle exec itsi restart]]
                 else
@@ -29,9 +33,9 @@ module Itsi
             @auto_reloading = true
 
             if ENV["BUNDLE_BIN_PATH"]
-              watch "Itsi.rb", [%w[bundle exec itsi restart]]
+              watch src, [%w[bundle exec itsi restart]]
             else
-              watch "Itsi.rb", [%w[itsi restart]]
+              watch src, [%w[itsi restart]]
             end
           end
         end

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

@@ -26,8 +26,11 @@ module Itsi
             end
           end
 
-          code = IO.read("#{included_file}.rb")
-          location.instance_eval(code, "#{included_file}.rb", 1)
+          filename =  File.expand_path("#{included_file}.rb")
+
+          code = IO.read(filename)
+          location.instance_eval(code, filename, 1)
+
         end
 
       end

data/gems/server/lib/itsi/server/config/options/listen_backlog.rb

@@ -4,7 +4,7 @@ module Itsi
       class ListenBacklog < Option
 
         insert_text <<~SNIPPET
-        listen_backlog ${1|262_144,1_048_576|}
+        listen_backlog ${1|1024,2048,4096|}
         SNIPPET
 
         detail "Specifies the size of the listen backlog for the socket. Larger backlog sizes can improve performance for high-throughput applications by allowing more pending connections to queue, but may increase memory usage. The default value is 1024."

data/gems/server/lib/itsi/server/config/options/pipeline_flush.md

@@ -0,0 +1,16 @@
+---
+title: Pipeline Flush
+url: /options/pipeline_flush
+---
+
+Aggregates flushes to better support pipelined responses. (HTTP1 only)
+The default value is `false`.
+
+## Configuration
+```ruby {filename=Itsi.rb}
+pipeline_flush true
+```
+
+```ruby {filename=Itsi.rb}
+pipeline_flush false
+```

data/gems/server/lib/itsi/server/config/options/pipeline_flush.rb

@@ -0,0 +1,19 @@
+module Itsi
+  class Server
+    module Config
+      class PipelineFlush < Option
+
+        insert_text <<~SNIPPET
+        pipeline_flush ${1|true,false|}
+        SNIPPET
+
+        detail "Aggregates flushes to better support pipelined responses. (HTTP1 only)."
+
+        schema do
+          (Bool() & Required()).default(false)
+        end
+
+      end
+    end
+  end
+end

data/gems/server/lib/itsi/server/config/options/send_buffer_size.md

@@ -0,0 +1,15 @@
+---
+title: Send Buffer Size
+url: /options/send_buffer_size
+---
+
+Configures the size of the send buffer for the socket. Larger buffer sizes can improve performance for high-throughput applications but may increase memory usage. The default value is 262,144 bytes.
+
+## Configuration
+```ruby {filename=Itsi.rb}
+send_buffer_size 262_144
+```
+
+```ruby {filename=Itsi.rb}
+send_buffer_size 1_048_576
+```

data/gems/server/lib/itsi/server/config/options/send_buffer_size.rb

@@ -0,0 +1,19 @@
+module Itsi
+  class Server
+    module Config
+      class SendBufferSize < Option
+
+        insert_text <<~SNIPPET
+        send_buffer_size ${1|262_144,1_048_576|}
+        SNIPPET
+
+        detail "Specifies the size of the send buffer for the socket. Larger buffer sizes can improve performance for high-throughput applications but may increase memory usage. The default value is 262,144 bytes."
+
+        schema do
+          (Type(Integer) & Range(1..Float::INFINITY) & Required()).default(262_144)
+        end
+
+      end
+    end
+  end
+end

data/gems/server/lib/itsi/server/config/options/writev.md

@@ -0,0 +1,25 @@
+---
+title: Write Vectored
+url: /options/writev
+---
+
+Set whether HTTP/1 connections should try to use vectored writes,
+or always flatten into a single buffer.
+
+Note that setting this to false may mean more copies of body data,
+but may also improve performance when an IO transport doesn't
+support vectored writes well, such as most TLS implementations.
+
+Setting this to true will force hyper to use queued strategy
+which may eliminate unnecessary cloning on some TLS backends
+
+Default is `nil` in which case hyper will try to guess which mode to use
+
+## Configuration
+```ruby {filename=Itsi.rb}
+writev true
+```
+
+```ruby {filename=Itsi.rb}
+writev false
+```

data/gems/server/lib/itsi/server/config/options/writev.rb

@@ -0,0 +1,19 @@
+module Itsi
+  class Server
+    module Config
+      class Writev < Option
+
+        insert_text <<~SNIPPET
+        writev ${1|true,false|}
+        SNIPPET
+
+        detail "Set whether HTTP/1 connections should try to use vectored writes"
+
+        schema do
+          (Bool() & Required()).default(false)
+        end
+
+      end
+    end
+  end
+end

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

@@ -41,39 +41,43 @@ module Itsi
             DSL.evaluate(&builder_proc)
           elsif args[:static]
             DSL.evaluate do
-              location "*" do
-                rate_limit key: "address", store_config: "in_memory", requests: 2, seconds: 5
-                etag type: "strong", algorithm: "md5", min_body_size: 1024 * 1024
-                compress min_size: 1024 * 1024, level: "fastest", algorithms: %w[zstd gzip br deflate],
-                         mime_types: %w[all], compress_streams: true
-                log_requests before: { level: "INFO", format: "[{request_id}] {method} {path_and_query} - {addr} " },
-                             after: { level: "INFO",
-                                      format: "[{request_id}] └─ {status} in {response_time}" }
-                static_assets \
-                  relative_path: true,
-                  allowed_extensions: [],
-                  root_dir: ".",
-                  not_found_behavior: { error: "not_found" },
-                  auto_index: true,
-                  try_html_extension: true,
-                  max_file_size_in_memory: 1024 * 1024, # 1MB
-                  max_files_in_memory: 1000,
-                  file_check_interval: 1,
-                  serve_hidden_files: false,
-                  headers: {
-                    "X-Content-Type-Options" => "nosniff"
-                  }
-              end
+              rate_limit key: "address", store_config: "in_memory", requests: 5, seconds: 10
+              etag type: "strong", algorithm: "md5", min_body_size: 1024 * 1024
+              compress min_size: 1024 * 1024, level: "fastest", algorithms: %w[zstd gzip br deflate],
+                       mime_types: %w[all], compress_streams: true
+              log_requests before: { level: "DEBUG", format: "[{request_id}] {method} {path_and_query} - {addr} " },
+                           after: { level: "DEBUG",
+                                    format: "[{request_id}] └─ {status} in {response_time}" }
+              nodelay false
+              static_assets \
+                relative_path: true,
+                allowed_extensions: [],
+                root_dir: ".",
+                not_found_behavior: { error: "not_found" },
+                auto_index: true,
+                try_html_extension: true,
+                max_file_size_in_memory: 1024 * 1024, # 1MB
+                max_files_in_memory: 1000,
+                file_check_interval: 1,
+                serve_hidden_files: false,
+                headers: {
+                  "X-Content-Type-Options" => "nosniff"
+                }
             end
           elsif File.exist?(config_file_path.to_s)
-            DSL.evaluate(config_file_path)
+            DSL.evaluate do
+              include config_file_path.gsub(".rb", "")
+              rackup_file args[:rackup_file], script_name: "/" if args.key?(:rackup_file)
+            end
           elsif File.exist?("./config.ru")
             DSL.evaluate do
               preload true
-              rackup_file args.fetch(:rackup_file, "./config.ru")
+              rackup_file args.fetch(:rackup_file, "./config.ru"), script_name: "/"
             end
           else
-            DSL.evaluate {}
+            DSL.evaluate do
+              rackup_file args[:rackup_file], script_name: "/" if args.key?(:rackup_file)
+            end
           end
 
         itsifile_config.transform_keys!(&:to_sym)
@@ -106,9 +110,8 @@ module Itsi
           Server.write_pid
         end
 
-
         srv_config = {
-          workers: args.fetch(:workers) { itsifile_config.fetch(:workers, 1) },
+          workers: args.fetch(:workers) { itsifile_config.fetch(:workers, nil) },
           worker_memory_limit: args.fetch(:worker_memory_limit) { itsifile_config.fetch(:worker_memory_limit, nil) },
           silence: args.fetch(:silence) { itsifile_config.fetch(:silence, false) },
           shutdown_timeout: args.fetch(:shutdown_timeout) { itsifile_config.fetch(:shutdown_timeout, 5) },
@@ -129,7 +132,7 @@ module Itsi
           multithreaded_reactor: args.fetch(:multithreaded_reactor) do
             itsifile_config.fetch(:multithreaded_reactor, nil)
           end,
-          pin_worker_cores: args.fetch(:pin_worker_cores) { itsifile_config.fetch(:pin_worker_cores, true) },
+          pin_worker_cores: args.fetch(:pin_worker_cores) { itsifile_config.fetch(:pin_worker_cores, false) },
           scheduler_class: args.fetch(:scheduler_class) { itsifile_config.fetch(:scheduler_class, nil) },
           oob_gc_responses_threshold: args.fetch(:oob_gc_responses_threshold) do
             itsifile_config.fetch(:oob_gc_responses_threshold, nil)
@@ -141,14 +144,21 @@ module Itsi
           log_format: args.fetch(:log_format) { itsifile_config.fetch(:log_format, nil) },
           log_target: args.fetch(:log_target) { itsifile_config.fetch(:log_target, nil) },
           log_target_filters: args.fetch(:log_target_filters) { itsifile_config.fetch(:log_target_filters, nil) },
+          pipeline_flush: itsifile_config.fetch(:pipeline_flush, true),
+          writev: itsifile_config.fetch(:writev, false),
+          max_concurrent_streams: itsifile_config.fetch(:max_concurrent_streams, nil),
+          max_local_error_reset_streams: itsifile_config.fetch(:max_local_error_reset_streams, nil),
+          max_header_list_size: itsifile_config.fetch(:max_header_list_size, 2 * 1024 * 1024),
+          max_send_buf_size: itsifile_config.fetch(:max_send_buf_size, 64 * 1024),
           binds: args.fetch(:binds) { itsifile_config.fetch(:binds, ["http://0.0.0.0:3000"]) },
           middleware_loader: middleware_loader,
-          listeners: args.fetch(:listeners) { nil },
+          listeners: args.fetch(:listeners, nil),
           reuse_address: itsifile_config.fetch(:reuse_address, true),
           reuse_port: itsifile_config.fetch(:reuse_port, true),
           listen_backlog: itsifile_config.fetch(:listen_backlog, 1024),
           nodelay: itsifile_config.fetch(:nodelay, true),
-          recv_buffer_size: itsifile_config.fetch(:recv_buffer_size, 262_144)
+          recv_buffer_size: itsifile_config.fetch(:recv_buffer_size, 262_144),
+          send_buffer_size: itsifile_config.fetch(:send_buffer_size, 262_144)
         }.transform_keys(&:to_s)
 
         [srv_config, errors_to_error_lines(errors)]
@@ -223,6 +233,8 @@ module Itsi
 
       # Find config file path, if it exists.
       def self.config_file_path(config_file_path = nil)
+        raise "Config file #{config_file_path} does not exist" if config_file_path && !File.exist?(config_file_path)
+
         config_file_path ||= \
           if File.exist?(ITSI_DEFAULT_CONFIG_FILE)
             ITSI_DEFAULT_CONFIG_FILE

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

@@ -10,10 +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.fetch("ITSI_WORKERS") {
-  require "etc"
-  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

data/gems/server/lib/itsi/server/grpc/grpc_call.rb

@@ -190,6 +190,8 @@ module Itsi
       end
     end
 
+    alias_method :each, :each_remote_read
+
     def bidi_streamer?
       input_stream? && output_stream?
     end

data/gems/server/lib/itsi/server/grpc/grpc_interface.rb

@@ -79,7 +79,7 @@ module Itsi
       end
 
       def handle_client_streaming(active_call)
-        response = service.send(active_call.method_name, active_call.each_remote_read, active_call)
+        response = service.send(active_call.method_name, active_call)
         active_call.remote_send(response)
       end
 
@@ -94,7 +94,7 @@ module Itsi
       end
 
       def handle_bidi_streaming(active_call)
-        result = service.send(active_call.method_name, active_call.each_remote_read, active_call) do |response|
+        result = service.send(active_call.method_name, active_call.each, active_call) do |response|
           active_call.remote_send(response)
         end
         return unless result.is_a?(Enumerator)

data/gems/server/lib/itsi/server/rack/handler/itsi.rb

@@ -8,7 +8,9 @@ module Rack
         port = options.fetch(:Port, 3001)
         ::Itsi::Server.start(
           {
-            binds: ["http://#{host}:#{port}"]
+            binds: ["http://#{host}:#{port}"],
+            threads: 5,
+            workers: 1
           }
         ) do
           run app

data/gems/server/lib/itsi/server/rack_interface.rb

@@ -12,7 +12,7 @@ module Itsi
           end
         end
         lambda do |request|
-          Server.respond(request, app.call(request.to_rack_env))
+          Server.respond(request, app.call(env = request.to_rack_env), env)
         end
       end
 
@@ -20,14 +20,14 @@ module Itsi
       # Here we build the env, and invoke the Rack app's call method.
       # We then turn the Rack response into something Itsi server understands.
       def call(app, request)
-        respond request, app.call(request.to_rack_env)
+        respond request, app.call(env = request.to_rack_env), env
       end
 
       # Itsi responses are asynchronous and can be streamed.
       # Response chunks are sent using response.send_frame
       # and the response is finished using response.close_write.
       # If only a single chunk is written, you can use the #send_and_close method.
-      def respond(request, (status, headers, body))
+      def respond(request, (status, headers, body), env)
         response = request.response
 
         # Don't try and respond if we've been hijacked.
@@ -39,13 +39,16 @@ module Itsi
 
         # 2. Set Headers
         body_streamer = streaming_body?(body) ? body : headers.delete("rack.hijack")
-        headers.each do |key, value|
-          if value.is_a?(Array)
+
+        response.reserve_headers(headers.size)
+
+        for key, value in headers
+          case value
+          when String then response[key] = value
+          when Array
             value.each do |v|
               response[key] = v
             end
-          elsif value.is_a?(String)
-            response[key] = value
           end
         end
 
@@ -53,15 +56,15 @@ module Itsi
         # As soon as we start setting the response
         # the server will begin to stream it to the client.
 
-        # If we're partially hijacked or returned a streaming body,
-        # stream this response.
 
         if body_streamer
+          # If we're partially hijacked or returned a streaming body,
+          # stream this response.
           body_streamer.call(response)
 
-        # If we're enumerable with more than one chunk
-        # also stream, otherwise write in a single chunk
         elsif body.respond_to?(:each) || body.respond_to?(:to_ary)
+          # If we're enumerable with more than one chunk
+          # also stream, otherwise write in a single chunk
           unless body.respond_to?(:each)
             body = body.to_ary
             raise "Body #to_ary didn't return an array" unless body.is_a?(Array)
@@ -78,8 +81,10 @@ module Itsi
         else
           response.send_and_close(body.to_s)
         end
+      rescue EOFError
+        response.close
       ensure
-        response.close_write
+        RackEnvPool.checkin(env)
         body.close if body.respond_to?(:close)
       end
 

data/gems/server/lib/itsi/server/route_tester.rb

@@ -23,7 +23,7 @@ module Itsi
         when "cors"
           "\e[33mcors\e[0m(#{mw_args["allow_origins"].join(" ")}, #{mw_args["allow_methods"].join(" ")})"
         when "etag"
-          "\e[33metag\e[0m(#{mw_args["type"]}/#{mw_args["algorithm"]}, #{mw_args["handle_if_none_match"] ? "if_none_match" : ""})"
+          "\e[33metag\e[0m(#{mw_args["type"]}/#{mw_args["algorithm"]})"
         when "cache_control"
           "\e[33mcache_control\e[0m(max_age: #{mw_args["max_age"]}, #{mw_args.select do |_, v|
             v == true

data/gems/server/lib/itsi/server/scheduler_interface.rb

@@ -14,6 +14,8 @@ module Itsi
       def schedule(app, request)
         Fiber.schedule do
           app.call(request)
+        rescue StandardError => e
+          request.server_error(e.message)
         end
       end
     end

data/gems/server/lib/itsi/server/version.rb

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

data/gems/server/lib/itsi/server.rb

@@ -12,6 +12,7 @@ require_relative "server/rack/handler/itsi"
 require_relative "server/config"
 require_relative "server/typed_handlers"
 require_relative "standard_headers"
+require_relative "rack_env_pool"
 require_relative "http_request"
 require_relative "http_response"
 require_relative "passfile"