Features

• zstd, br, gzip and deflate compression.
• Conditional compression based on route, content-type and body size
• Streaming compression
• Serve static precompressed files from the file-system
• gRPC compression (zlib and gzip)
• See compression

• Full control over CORS rules on a location-by-location basis.
• See cors

• Weak and Strong eTag support.
• If-None-Match and If-Modified-Since support.
• Automated etag generation for dynamic content (or forwarding of existing etags if present)
• See etag and cache_control

• Expressive controls to apply middleware selectively on a request-by-request basis.
• Expressive matching based on route, content-type and body size, hostnames etc.
• A single Itsi process can support simultaneous running of several apps, each with specialized configuration.
• See location

• Simple redirect functionality (all of permanent, temporary, found, moved_permanently)
• HTTP to HTTPS Redirects
• Dynamic URL Rewriting
• See redirect

• Seamlessly Proxy to downstream HTTP services
• Hostname and SNI overrides
• Header overrides
• Multiple backends per host, with load balancing and failover support
• Automatic retries for Idempotent requests
• Configurable error pages
• See proxy

• Partial content delivery support, so clients can resume downloads or stream large files efficiently.
• See static_assets

Efficiently serves static assets with proper content types and caching headers.

• Auto index generation
• Configurable in-memory caching for faster serving of small and frequently accessed files.
• Auto try .html extension (for cleaner paths)
• Configurable fallback behaviour (e.g. route request misses to an index.html for SPAs)
• See static_assets

• Itsi can listen on multiple IP addresses or ports simultaneously for flexible deployment.
• Unix socket binds (both plain-text and TLS) are supported.
• See bind.

• Monitors file changes and to automatically reloads configuration or content.
• Use custom watchers to e.g. trigger frontend builds on file changes.
• See local_development, auto_reload_config, and watch.

• The bundled RubyLSP addon provides rich inline documentation and hover support when editing Itsi.rb files.
• Shell completion support (add eval "$(itsi --install-completions)" to the bottom of your shell init file)
• See local_development.

• Send SIGUSR2 to trigger detailed status report across all Itsi processes.
• See signals.

• Support logging using plain-text and structured JSON formats.
• Support STDOUT, file-system and combined log sinks.
• Apply selective log levels for specific log targets only.
• Configurable request logging middleware, with custom log templates.
• See Request Logs & Logging.

• Zero-downtime config file reloads.
• Phased restart support when running in cluster mode
• Config file testing and dry-run functionality
• See signals and auto_reload_config.

• Provide your own exception responses (HTML and JSON) for all common exception scenarios, or simply rely on the light-weight defaults.
• See error_responses.

• Use a full suite of Unix signals to control your live Itsi cluster.
• Add or remove workers on the fly, reload config, generate status reports etc.
• See signals.

• Apply common authentication patterns at the middleware layer.
• API Key (bcrypt, argon2, sha256, sha512)
• JWT (hs256, HS384, HS512, RS256, RS384, RS512, ES256, ES384, PS256, PS384, PS512)
• Basic Auth (bcrypt, argon2, sha256, sha512)

Itsi also comes bundled with a passfile generator, to help you manage your password hashes effectively.

• See auth_jwt, auth_api_key, auth_basic and passfile.

• Automated provisioning of Let’s Encrypt certificates.
• File system caching of certificate data to avoid excessive API calls.
• Supports usage of subject alternative names (SANs) for certificates that span multiple domains/sub-domains.
• See certificates.

• Easily mirror your production SSL set-up in Development
• Custom local CA generation (add this CA cert to your trusted root certificates for warning-less SSL during local development)
• See certificates.

• Combine any number of configurable rate limits
• Support for a Redis backend for distributed rate limiting (falls back to in-memory backend)
• In-memory backend for simple setups and local development.
• See rate_limit.

• IP Allow lists to limit access to a specific set of IP addresses or blocks.
• IP Deny lists to block access from specific IP addresses or blocks.
• See allow_list & deny_list.

• Automatically scan request paths and headers for known malicious patterns
• Configurable ban rules to block offenders for a specified duration.
• See intrusion_protection

• Protections against several slowhttp attacks (e.g. Slowloris, Slowbody), through header and request timeouts and maximum request body sizes.
• See max_body, request_timeout and header_read_timeout

• Simple configuration for enabling CSP headers.
• Support for hosting a CSP reporting endpoint to track violations of CSPs running in reporting only mode.
• See CSP

• Benefit from connection multiplexing by using http2 all the way from client to app/file server.
• Itsi’s underlying HTTP1 and 2 implementations are provided directly by hyper. Itsi simply exposes these existing capabilities. This means that once h3 lands in Hyper - we’ll get it in Itsi too!

• Rack compliant. Itsi plays nicely with your existing Rack-based applications and middleware.
• See run and rackup_file

• Itsi is compatible with ruby grpc service handlers and can replace the official Ruby gRPC server implementation for a free performance boost!
• Consider enabling non-blocking IO to further enhance performance.
• Support for gRPC server reflection (use with tools like evans and Postman for easy service discovery)
• Support for gzip and zlib compression
• See grpc

• Itsi provides a gRPC+REST compatibility layer for easy reuse of gRPC endpoints by clients and environments that are not gRPC capable. Invoke unidirectional and streaming endpoints using plain-old JSON.
• See grpc

• WebSocket support for Rack apps (e.g. ActionCable)

• Supports running in a clustered mode, to fully leverage multi-core systems.
• See workers.

• Support for Ruby’s fiber scheduler for non-blocking concurrency, boosting performance during I/O operations.
• Use Itsi’s own high-performance built-in Fiber Scheduler or if your prefer you can bring your own!
• See fiber_scheduler.

• Itsi allows you to split endpoints between using a Fiber scheduler versus running using the traditional blocking IO model. This allows you to dip your toes into the waters of Ruby’s new non-blocking IO, without having to port an entire application at once!
• See scheduler_threads.

• Itsi is underpinned by hyper and tokio and as such is fundamentally an evented, non-blocking server. Whether you’re proxying, serving large files, or delegating to Ruby endpoints, Itsi remains responsive, even under heavy load.

• Preload your Ruby application code before forking to benefit from reduced memory through CoW
• Alternatively, use groups in bundler to target specific gems or dependencies for preloading
• See preload.

• For both streaming and Enumerable bodies, Itsi sends data to the client as soon as it is available. This means modules like ActionController behave as expected, and the minimal buffering keeps Itsi’s memory footprint consistently low.

• Itsi supports streaming incoming request bodies too, for efficient processing of large simultaneous input streams (Disabled by default for maximum compatibility).
• See stream_body.

• Itsi supports both full and partial Rack hijacking. Even over HTTP2!

• Itsi allows Ruby apps to set a X-Sendfile header to enable efficient, streaming file transfers, outside of Ruby, via fast native code.
• See run and rackup_file.

• Itsi allows you to specify memory limits for Ruby processes. When the limit is reached, Itsi gracefully terminates the process and also invokes a dedicated after_memory_threshold_reached callback, so that you can log the event for further analysis.
• See worker_memory_limit and after_memory_threshold_reached.

• Itsi can be configured to periodically trigger GC every N idle periods (where an idle period is defined as a time where no requests are currently queued).
• Periodic triggering of GC outside of the request flow can help reduce the impact of GC on latency.
• See oob_gc_threshold

• Itsi allows definition of ultra-light-weight Ruby web-apps, using plain old functions and procs.
• For simple endpoints this barebones option can provide a substantial increase in throughput over a Rack request (primarily by avoiding allocating the env hash and response array)
• See endpoint