itsi-server 0.1.1 → 0.1.20

data/lib/itsi/server/config.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+module Itsi
+  class Server
+    module Config
+      require_relative "config/typed_struct"
+      require_relative "config/dsl"
+      require_relative "config/known_paths"
+      require_relative "default_app/default_app"
+
+      ITSI_DEFAULT_CONFIG_FILE = "Itsi.rb"
+
+      def self.prep_reexec!
+        @argv ||= ARGV[0...ARGV.index("--listeners")]
+
+        auto_suppress_fork_darwin_fork_safety_warnings = [
+          ENV["OBJC_DISABLE_INITIALIZE_FORK_SAFETY"].nil? || ENV["PGGSSENCMODE"].nil?,
+          RUBY_PLATFORM =~ /darwin/,
+          !ENV.key?("ITSI_DISABLE_AUTO_DISABLE_DARWIN_FORK_SAFETY_WARNINGS"),
+          $PROGRAM_NAME =~ /itsi$/
+        ].all?
+        return unless auto_suppress_fork_darwin_fork_safety_warnings
+
+        env = ENV.to_h.merge("OBJC_DISABLE_INITIALIZE_FORK_SAFETY" => "YES", "PGGSSENCMODE" => "disable")
+        if ENV["BUNDLE_BIN_PATH"]
+          exec env, "bundle", "exec", $PROGRAM_NAME, *@argv
+        else
+          exec env, $PROGRAM_NAME, *@argv
+        end
+      end
+
+      # The configuration used when launching the Itsi server are evaluated in the following precedence:
+      # 1. CLI Args.
+      # 2. Itsi.rb file.
+      # 3. Default values.
+      def self.build_config(args, config_file_path, builder_proc = nil)
+        args.transform_keys!(&:to_sym)
+        itsifile_config, errors = \
+          if builder_proc
+            DSL.evaluate(&builder_proc)
+          elsif args[:static]
+            DSL.evaluate do
+              location "/" do
+                allow_list allowed_patterns: ['127.0.0.1']
+                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 brotli 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
+            end
+          elsif File.exist?(config_file_path.to_s)
+            DSL.evaluate(config_file_path)
+          elsif File.exist?("./config.ru")
+            DSL.evaluate do
+              preload true
+              rackup_file args.fetch(:rackup_file, "./config.ru")
+            end
+          else
+            DSL.evaluate{}
+          end
+
+        itsifile_config.transform_keys!(&:to_sym)
+
+        # We'll preload while we load config, if enabled.
+        middleware_loader = itsifile_config.fetch(:middleware_loader, -> {})
+        preload = args.fetch(:preload) { itsifile_config.fetch(:preload, false) }
+
+        case preload
+        # If we preload everything, then we'll load middleware and default rack app ahead of time
+        when true
+          preloaded_middleware = middleware_loader.call
+          middleware_loader = -> { preloaded_middleware }
+        # If we're just preloading a specific gem group, we'll do that here too
+        when Symbol
+          Bundler.require(preload)
+        end
+
+        [
+          {
+            workers: args.fetch(:workers) { itsifile_config.fetch(:workers, 1) },
+            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) },
+            hooks: itsifile_config.fetch(:hooks, nil),
+            preload: !!preload,
+            request_timeout: itsifile_config.fetch(:request_timeout, nil),
+            header_read_timeout: args.fetch(:header_read_timeout) { itsifile_config.fetch(:header_read_timeout, nil) },
+            notify_watchers: itsifile_config.fetch(:notify_watchers, nil),
+            threads: args.fetch(:threads) { itsifile_config.fetch(:threads, 1) },
+            scheduler_threads: args.fetch(:scheduler_threads) { itsifile_config.fetch(:scheduler_threads, nil) },
+            streamable_body: args.fetch(:streamable_body) { itsifile_config.fetch(:streamable_body, false) },
+            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) },
+            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)
+            end,
+            log_level: args.fetch(:log_level) { itsifile_config.fetch(:log_level, nil) },
+            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) },
+            binds: args.fetch(:binds) { itsifile_config.fetch(:binds, ["http://0.0.0.0:3000"]) },
+            middleware_loader: middleware_loader,
+            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)
+          }.transform_keys(&:to_s),
+
+          errors.flat_map do |(error, message)|
+            location =  message[/(.*?)\:in/,1]
+            file, lineno = location.split(":")
+            lineno = lineno.to_i
+            err_message = error.kind_of?(NoMethodError) ? error.detailed_message : error.message
+            file_lines = IO.readlines(file)
+            info_lines = if error.kind_of?(SyntaxError)
+              []
+            else
+              ([lineno-2, 0].max...[file_lines.length, lineno.succ.succ].min).map do |currline|
+                [
+                  " #{currline.succ.to_s.rjust(3)} | #{file_lines[currline].strip}",
+                  if currline == lineno-1
+                    "     | ^^^ "
+                  end
+                ].compact
+              end.flatten
+            end
+            [
+              err_message,
+              "   --> #{File.expand_path(file)}:#{lineno}",
+              *info_lines
+            ]
+          end
+        ]
+      end
+
+      def self.test!(cli_params)
+        _, errors = build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file]))
+        if errors.any?
+          Itsi.log_error("Config file is invalid")
+          puts errors
+        else
+          Itsi.log_info("Config file is valid")
+        end
+      end
+
+      # Reloads the entire process
+      # using exec, passing in any active file descriptors
+      # and previous invocation arguments
+      def self.reload_exec(listener_info)
+        if ENV["BUNDLE_BIN_PATH"]
+          exec "bundle", "exec", $PROGRAM_NAME, *@argv, "--listeners", listener_info
+        else
+          exec $PROGRAM_NAME, *@argv, "--listeners", listener_info
+        end
+      end
+
+      # Find config file path, if it exists.
+      def self.config_file_path(config_file_path = nil)
+        config_file_path ||= \
+          if File.exist?(ITSI_DEFAULT_CONFIG_FILE)
+            ITSI_DEFAULT_CONFIG_FILE
+          elsif File.exist?("config/#{ITSI_DEFAULT_CONFIG_FILE}")
+            "config/#{ITSI_DEFAULT_CONFIG_FILE}"
+          end
+        # Options simply pass through unless we've specified a config file
+        return unless File.exist?(config_file_path.to_s)
+
+        config_file_path
+      end
+
+      def self.pid_file_path
+        if Dir.exist?("tmp")
+          File.join("tmp", "itsi.pid")
+        else
+          ".itsi.pid"
+        end
+      end
+
+      # Write a default config file, if one doesn't exist.
+      def self.write_default
+        if File.exist?(ITSI_DEFAULT_CONFIG_FILE)
+          puts "#{ITSI_DEFAULT_CONFIG_FILE} already exists."
+          return
+        end
+
+        default_config = IO.read("#{__dir__}/default_config/Itsi.rb")
+
+        if File.exist?("./config.ru")
+          default_config << <<~RUBY
+          # You can mount several Ruby apps as either
+          # 1. rackup files
+          # 2. inline rack apps
+          # 3. inline Ruby endpoints
+          #
+          # 1. rackup_file
+          rackup_file "./config.ru"
+          #
+          # 2. inline rack app
+          # require 'rack'
+          # run(Rack::Builder.app do
+          #   use Rack::CommonLogger
+          #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+          # end)
+          #
+          # 3. Endpoints
+          # endpoint "/" do |req|
+          #   req.ok "Hello from Itsi"
+          # end
+          RUBY
+        else
+          default_config << <<~RUBY
+            # You can mount several Ruby apps as either
+            # 1. rackup files
+            # 2. inline rack apps
+            # 3. inline Ruby endpoints
+            #
+            # 1. rackup_file
+            # Use `rackup_file` to specify the Rack app file name.
+            #
+            # 2. inline rack app
+            # require 'rack'
+            # run(Rack::Builder.app do
+            #   use Rack::CommonLogger
+            #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+            # end)
+            #
+            # 3. Endpoint
+            endpoint "/" do |req|
+              req.ok "Hello from Itsi"
+            end
+          RUBY
+        end
+
+        File.open(ITSI_DEFAULT_CONFIG_FILE, "w") do |file|
+          file.write(default_config)
+        end
+
+      end
+    end
+  end
+end

data/lib/itsi/server/default_app/default_app.rb

@@ -0,0 +1,34 @@
+# When you Run Itsi without a Rack app,
+# we start a tiny little echo server, just so you can see it in action.
+DEFAULT_INDEX = IO.read("#{__dir__}/index.html").freeze
+DEFAULT_BINDS = ["http://0.0.0.0:3000"].freeze
+DEFAULT_APP = lambda {
+  require "json"
+
+  Itsi::Server::RackInterface.for(lambda do |env|
+    headers, body = \
+      if env["itsi.response"].json?
+        [
+          { "Content-Type" => "application/json" },
+          [{ "message" => "You're running on Itsi!", "rack_env" => env,
+              "version" => Itsi::Server::VERSION }.to_json]
+        ]
+      else
+        [
+          { "Content-Type" => "text/html" },
+          [
+            format(
+              DEFAULT_INDEX,
+              REQUEST_METHOD: env["REQUEST_METHOD"],
+              PATH_INFO: env["PATH_INFO"],
+              SERVER_NAME: env["SERVER_NAME"],
+              SERVER_PORT: env["SERVER_PORT"],
+              REMOTE_ADDR: env["REMOTE_ADDR"],
+              HTTP_USER_AGENT: env["HTTP_USER_AGENT"]
+            )
+          ]
+        ]
+      end
+    [200, headers, body]
+  end)
+}

data/lib/itsi/server/default_app/index.html

@@ -0,0 +1,115 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Itsi - Default</title>
+    <style>
+      :root {
+        --bg-color: #f0f2f5;
+        --text-color: #333;
+        --link-color: #0052cc;
+      }
+      *,
+      *::before,
+      *::after {
+        box-sizing: border-box;
+      }
+      body {
+        margin: 0;
+        font-family: "Helvetica Neue", Arial, sans-serif;
+        background: var(--bg-color);
+        color: var(--text-color);
+        line-height: 1.6;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        padding: 3rem 1rem;
+      }
+      header {
+        text-align: center;
+        margin-bottom: 2rem;
+      }
+      h1 {
+        font-size: 2.5rem;
+        margin-bottom: 0.5rem;
+      }
+      p {
+        font-size: 1.5rem;
+        margin-bottom: 2rem;
+        color: #555;
+      }
+      ul.fields {
+        list-style: none;
+        padding: 0;
+        margin: 0;
+        max-width: 100%%;
+        width: 100%%;
+      }
+      ul.fields li {
+        display: flex;
+        justify-content: space-between;
+        padding: 1rem;
+        border-bottom: 1px solid #ddd;
+      }
+      ul.fields li:last-child {
+        border-bottom: none;
+      }
+      .label {
+        font-weight: bold;
+        margin-right: 1rem;
+      }
+      /* Make it expansive: let content use more horizontal space on larger screens */
+      main {
+        max-width: 1200px;
+        width: 100%%;
+      }
+      /* Responsive adjustments for small devices */
+      @media (max-width: 480px) {
+        h1 {
+          font-size: 2.5rem;
+        }
+        p {
+          font-size: 1.2rem;
+        }
+        ul.fields li {
+          padding: 0.75rem;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <header>
+        <h1>You're running on Itsi!</h1>
+        <p>RACK environment:</p>
+      </header>
+      <ul class="fields">
+        <li>
+          <span class="label">REQUEST_METHOD:</span>
+          <span>%{REQUEST_METHOD}</span>
+        </li>
+        <li>
+          <span class="label">PATH_INFO:</span>
+          <span>%{PATH_INFO}</span>
+        </li>
+        <li>
+          <span class="label">SERVER_NAME:</span>
+          <span>%{SERVER_NAME}</span>
+        </li>
+        <li>
+          <span class="label">SERVER_PORT:</span>
+          <span>%{SERVER_PORT}</span>
+        </li>
+        <li>
+          <span class="label">REMOTE_ADDR:</span>
+          <span>%{REMOTE_ADDR}</span>
+        </li>
+        <li>
+          <span class="label">HTTP_USER_AGENT:</span>
+          <span>%{HTTP_USER_AGENT}</span>
+        </li>
+      </ul>
+    </main>
+  </body>
+</html>

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# This is the default Itsi configuration file, installed when you run `itsi init`
+# It contains a sane starting point for configuring your Itsi server.
+# You can use this file in both development and production environments.
+# Most of the options in this file can be overridden by command line options.
+# Check out itsi -h to learn more about the command line options available to you.
+
+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
+}
+
+# Number of threads to spawn per worker process
+# For pure CPU bound applicationss, you'll get the best results keeping this number low
+# Setting a value of 1 is great for superficial benchmarks, but in reality
+# it's better to set this a bit higher to allow expensive requests to get overtaken and minimize head-of-line blocking
+threads ENV.fetch("ITSI_THREADS", 3)
+
+# If your application is IO bound (e.g. performing a lot of proxied HTTP requests, or heavy queries etc)
+# you can see *substantial* benefits from enabling this option.
+# To set this option, pass a string, not a class (as we will not have loaded the class yet)
+# E.g.
+# `fiber_scheduler "Itsi::Scheduler"` - The default fast and light-weight scheduler that comes with Itsi
+# `fiber_scheduler "Async::Scheduler"` - Bring your own scheduler!
+fiber_scheduler nil
+
+# By default Itsi will run the Rack app from config.ru.
+# You can provide an alternative Rack app file name here
+# Or you can inline the app directly inside Itsi.rb.
+# Only one of `run` and `rackup_file` can be used.
+# E.g.
+# require 'rack'
+# run(Rack::Builder.app do
+#   use Rack::CommonLogger
+#   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+# end)
+rackup_file "config.ru"
+
+# 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)
+# bind "https://localhost:3000"
+# bind "https://localhost: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.
+# 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"
+#
+# If you already have a certificate you can specify it using the cert and key parameters
+# bind "https://itsi.fyi?cert=/path/to/cert.pem&key=/path/to/key.pem"
+#
+# You can also bind to a unix socket or a tls unix socket. E.g.
+# bind "unix:///tmp/itsi.sock"
+# bind "tls:///tmp/itsi.secure.sock"
+
+if env == "development"
+  bind "http://localhost:3000"
+else
+  bind "https://0.0.0.0?domains=#{ENV["PRODUCTION_DOMAINS"]}&cert=acme&acme_email=admin@itsi.fyi"
+end
+
+# If you want to preload the application, set preload to true
+# to load the entire rack-app defined in rack_file_name before forking.
+# Alternatively, you can preload just a specific set of gems in a group in your gemfile,
+# by providing the group name here.
+# E.g.
+#
+# preload :preload # Load gems inside the preload group
+# preload false # Don't preload.
+#
+# If you want to be able to perform zero-downtime deploys using a single itsi process,
+# you should disable preloads, so that the application is loaded fresh each time a new worker boots
+preload true
+
+# Set the maximum memory limit for each worker process in bytes
+# When this limit is reached, the worker will be gracefully restarted.
+# Only one worker is restarted at a time to ensure we don't take down
+# 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,
+# write metrics to disk etc. etc.)
+after_memory_threshold_reached do |pid|
+  puts "Worker #{pid} has reached its memory threshold and will restart"
+end
+
+# Do clean up of any non-threadsafe resources before forking a new worker here.
+before_fork {}
+
+# Reinitialize any non-threadsafe resources after forking a new worker here.
+after_fork {}
+
+# Shutdown timeout
+# Number of seconds to wait for workers to gracefully shutdown before killing them.
+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.
+stream_body false
+
+# OOB GC responses threshold
+# Specifies how frequently OOB gc should be triggered during periods where there is a gap in queued requests.
+# Setting this too low can substantially worsen performance
+oob_gc_responses_threshold 512
+
+# Log level
+# Set this to one of the following values: debug, info, warn, error, fatal
+# Can also be set using the ITSI_LOG environment variable
+log_level :info
+
+# Log Format
+# Set this to be either :ansi or :json. If you leave it blank Itsi will try
+# and auto-detect the format based on the TTY environment.
+log_format :auto

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+# This is the default Itsi configuration file, installed when you run `itsi init`
+# It contains a sane starting point for configuring your Itsi server.
+# You can use this file in both development and production environments.
+# Most of the options in this file can be overridden by command line options.
+# Check out itsi -h to learn more about the command line options available to you.
+
+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
+}
+
+# Number of threads to spawn per worker process
+# For pure CPU bound applicationss, you'll get the best results keeping this number low
+# Setting a value of 1 is great for superficial benchmarks, but in reality
+# it's better to set this a bit higher to allow expensive requests to get overtaken and minimize head-of-line blocking
+threads ENV.fetch("ITSI_THREADS", 3)
+
+# If your application is IO bound (e.g. performing a lot of proxied HTTP requests, or heavy queries etc)
+# you can see *substantial* benefits from enabling this option.
+# To set this option, pass a string, not a class (as we will not have loaded the class yet)
+# E.g.
+# `fiber_scheduler "Itsi::Scheduler"` - The default fast and light-weight scheduler that comes with Itsi
+# `fiber_scheduler "Async::Scheduler"` - Bring your own scheduler!
+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)
+# bind "https://localhost:3000"
+# bind "https://localhost: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.
+# 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"
+#
+# If you already have a certificate you can specify it using the cert and key parameters
+# bind "https://itsi.fyi?cert=/path/to/cert.pem&key=/path/to/key.pem"
+#
+# You can also bind to a unix socket or a tls unix socket. E.g.
+# bind "unix:///tmp/itsi.sock"
+# bind "tls:///tmp/itsi.secure.sock"
+
+if env == "development"
+  bind "http://localhost:3000"
+else
+  bind "https://0.0.0.0?domains=#{ENV["PRODUCTION_DOMAINS"]}&cert=acme&acme_email=admin@itsi.fyi"
+end
+
+# If you want to preload the application, set preload to true
+# to load the entire rack-app defined in rack_file_name before forking.
+# Alternatively, you can preload just a specific set of gems in a group in your gemfile,
+# by providing the group name here.
+# E.g.
+#
+# preload :preload # Load gems inside the preload group
+# preload false # Don't preload.
+#
+# If you want to be able to perform zero-downtime deploys using a single itsi process,
+# you should disable preloads, so that the application is loaded fresh each time a new worker boots
+preload true
+
+# Set the maximum memory limit for each worker process in bytes
+# When this limit is reached, the worker will be gracefully restarted.
+# Only one worker is restarted at a time to ensure we don't take down
+# 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,
+# write metrics to disk etc. etc.)
+after_memory_threshold_reached do |pid|
+  puts "Worker #{pid} has reached its memory threshold and will restart"
+end
+
+# Do clean up of any non-threadsafe resources before forking a new worker here.
+before_fork {}
+
+# Reinitialize any non-threadsafe resources after forking a new worker here.
+after_fork {}
+
+# Shutdown timeout
+# Number of seconds to wait for workers to gracefully shutdown before killing them.
+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.
+stream_body false
+
+# OOB GC responses threshold
+# Specifies how frequently OOB gc should be triggered during periods where there is a gap in queued requests.
+# Setting this too low can substantially worsen performance
+oob_gc_responses_threshold 512
+
+# Log level
+# Set this to one of the following values: debug, info, warn, error, fatal
+# Can also be set using the ITSI_LOG environment variable
+log_level :info
+
+# Log Format
+# Set this to be either :ansi or :json. If you leave it blank Itsi will try
+# and auto-detect the format based on the TTY environment.
+log_format :auto