itsi-server 0.1.11 → 0.1.12

data/ext/itsi_tracing/src/lib.rs

@@ -1,58 +1,229 @@
-use std::env;
-
 use atty::{Stream, is};
-use tracing::level_filters::LevelFilter;
-pub use tracing::{debug, error, info, trace, warn};
-pub use tracing_attributes::instrument; // Explicitly export from tracing-attributes
-use tracing_subscriber::{
-    EnvFilter, Layer,
-    fmt::{self, format},
-    layer::SubscriberExt,
+use std::{
+    env,
+    sync::{Mutex, OnceLock},
 };
+pub use tracing::{debug, error, info, trace, warn};
+use tracing_appender::rolling;
+use tracing_subscriber::Layer;
+use tracing_subscriber::fmt::writer::BoxMakeWriter;
+use tracing_subscriber::{EnvFilter, fmt, prelude::*, reload};
+
+// Global reload handle for changing the level at runtime.
+static RELOAD_HANDLE: OnceLock<
+    Mutex<Option<reload::Handle<EnvFilter, tracing_subscriber::Registry>>>,
+> = OnceLock::new();
+
+/// Log format: Plain or JSON.
+#[derive(Debug, Clone)]
+pub enum LogFormat {
+    Plain,
+    Json,
+}
+
+/// Log target: STDOUT, File, or Both.
+#[derive(Debug, Clone)]
+pub enum LogTarget {
+    Stdout,
+    File(String), // file name (rotated daily)
+    Both(String), // file name (rotated daily) plus STDOUT
+}
+
+/// Logger configuration.
+#[derive(Debug, Clone)]
+pub struct LogConfig {
+    /// Log level as a string (e.g. "info", "debug").
+    pub level: String,
+    /// Format: Plain (with optional ANSI) or JSON.
+    pub format: LogFormat,
+    /// Target: STDOUT, File, or Both.
+    pub target: LogTarget,
+    /// Whether to enable ANSI coloring (for plain text).
+    pub use_ansi: bool,
+}
 
-#[instrument]
+impl Default for LogConfig {
+    fn default() -> Self {
+        let level = env::var("ITSI_LOG").unwrap_or_else(|_| "info".into());
+        let format = match env::var("ITSI_LOG_FORMAT").as_deref() {
+            Ok("json") => LogFormat::Json,
+            _ => LogFormat::Plain,
+        };
+        let target = match env::var("ITSI_LOG_TARGET").as_deref() {
+            Ok("file") => {
+                let file = env::var("ITSI_LOG_FILE").unwrap_or_else(|_| "app.log".into());
+                LogTarget::File(file)
+            }
+            Ok("both") => {
+                let file = env::var("ITSI_LOG_FILE").unwrap_or_else(|_| "app.log".into());
+                LogTarget::Both(file)
+            }
+            _ => LogTarget::Stdout,
+        };
+        // If ITSI_LOG_ANSI is set, use that; otherwise, use ANSI if stdout is a TTY.
+        let use_ansi = env::var("ITSI_LOG_ANSI")
+            .map(|s| s == "true")
+            .unwrap_or_else(|_| is(Stream::Stdout));
+        Self {
+            level,
+            format,
+            target,
+            use_ansi,
+        }
+    }
+}
+
+/// Initialize the global tracing subscriber with the default configuration.
 pub fn init() {
-    let env_filter = EnvFilter::builder()
-        .with_env_var("ITSI_LOG")
-        .try_from_env()
-        .unwrap_or_else(|_| EnvFilter::new("info"));
-
-    let format = fmt::format()
-        .compact()
-        .with_file(false)
-        .with_level(true)
-        .with_line_number(false)
-        .with_source_location(false)
-        .with_target(false)
-        .with_thread_ids(false);
-
-    let is_tty = is(Stream::Stdout);
-
-    let subscriber = tracing_subscriber::fmt()
-        .event_format(format)
-        .with_env_filter(env_filter);
-
-    if (is_tty && env::var("ITSI_LOG_PLAIN").is_err()) || env::var("ITSI_LOG_ANSI").is_ok() {
-        subscriber.with_ansi(true).init();
+    init_with_config(LogConfig::default());
+}
+
+/// Initialize the global tracing subscriber with a given configuration.
+pub fn init_with_config(config: LogConfig) {
+    // Build an EnvFilter from the configured level.
+    let env_filter = EnvFilter::new(config.level);
+
+    // Build the formatting layer based on target and format.
+    let fmt_layer = match config.target {
+        LogTarget::Stdout => match config.format {
+            LogFormat::Plain => fmt::layer()
+                .compact()
+                .with_file(false)
+                .with_line_number(false)
+                .with_target(false)
+                .with_thread_ids(false)
+                .with_writer(BoxMakeWriter::new(std::io::stdout))
+                .with_ansi(config.use_ansi)
+                .boxed(),
+            LogFormat::Json => fmt::layer()
+                .compact()
+                .with_file(false)
+                .with_line_number(false)
+                .with_target(false)
+                .with_thread_ids(false)
+                .with_writer(BoxMakeWriter::new(std::io::stdout))
+                .with_ansi(config.use_ansi)
+                .json()
+                .boxed(),
+        },
+        LogTarget::File(file) => match config.format {
+            LogFormat::Plain => fmt::layer()
+                .compact()
+                .with_file(false)
+                .with_line_number(false)
+                .with_target(false)
+                .with_thread_ids(false)
+                .with_writer(BoxMakeWriter::new({
+                    let file = file.clone();
+                    move || rolling::daily(".", file.clone())
+                }))
+                .with_ansi(false)
+                .boxed(),
+            LogFormat::Json => fmt::layer()
+                .compact()
+                .with_file(false)
+                .with_line_number(false)
+                .with_target(false)
+                .with_thread_ids(false)
+                .with_writer(BoxMakeWriter::new({
+                    let file = file.clone();
+                    move || rolling::daily(".", file.clone())
+                }))
+                .with_ansi(false)
+                .json()
+                .boxed(),
+        },
+        LogTarget::Both(file) => {
+            // For "Both" target, handle each format separately to avoid type mismatches
+            match config.format {
+                LogFormat::Plain => {
+                    let stdout_layer = fmt::layer()
+                        .compact()
+                        .with_file(false)
+                        .with_line_number(false)
+                        .with_target(false)
+                        .with_thread_ids(false)
+                        .with_writer(BoxMakeWriter::new(std::io::stdout))
+                        .with_ansi(config.use_ansi);
+
+                    let file_layer = fmt::layer()
+                        .compact()
+                        .with_file(false)
+                        .with_line_number(false)
+                        .with_target(false)
+                        .with_thread_ids(false)
+                        .with_writer(BoxMakeWriter::new({
+                            let file = file.clone();
+                            move || rolling::daily(".", file.clone())
+                        }))
+                        .with_ansi(false);
+
+                    stdout_layer.and_then(file_layer).boxed()
+                }
+                LogFormat::Json => {
+                    let stdout_layer = fmt::layer()
+                        .compact()
+                        .with_file(false)
+                        .with_line_number(false)
+                        .with_target(false)
+                        .with_thread_ids(false)
+                        .with_writer(BoxMakeWriter::new(std::io::stdout))
+                        .with_ansi(config.use_ansi)
+                        .json();
+
+                    let file_layer = fmt::layer()
+                        .compact()
+                        .with_file(false)
+                        .with_line_number(false)
+                        .with_target(false)
+                        .with_thread_ids(false)
+                        .with_writer(BoxMakeWriter::new({
+                            let file = file.clone();
+                            move || rolling::daily(".", file.clone())
+                        }))
+                        .with_ansi(false)
+                        .json();
+
+                    stdout_layer.and_then(file_layer).boxed()
+                }
+            }
+        }
+    };
+
+    // Create a reloadable filter layer so we can update the level at runtime.
+    let (filter_layer, handle) = reload::Layer::new(env_filter);
+
+    // Build the subscriber registry
+    let subscriber = tracing_subscriber::registry()
+        .with(filter_layer)
+        .with(fmt_layer);
+
+    tracing::subscriber::set_global_default(subscriber)
+        .expect("Unable to set global tracing subscriber");
+
+    RELOAD_HANDLE.set(Mutex::new(Some(handle))).unwrap();
+}
+
+/// Change the log level at runtime.
+pub fn set_level(new_level: &str) {
+    if let Some(handle) = RELOAD_HANDLE.get().unwrap().lock().unwrap().as_ref() {
+        handle
+            .modify(|filter| *filter = EnvFilter::new(new_level))
+            .expect("Failed to update log level");
     } else {
-        subscriber
-            .fmt_fields(format::JsonFields::default())
-            .event_format(fmt::format().json())
-            .init();
+        eprintln!("Reload handle not initialized; call init() first.");
     }
 }
 
+/// Run a function silently by temporarily setting a no-op subscriber.
 pub fn run_silently<F, R>(f: F) -> R
 where
     F: FnOnce() -> R,
 {
-    // Build a minimal subscriber that filters *everything* out
-    let no_op_subscriber =
-        tracing_subscriber::registry().with(fmt::layer().with_filter(LevelFilter::OFF));
-
-    // Turn that subscriber into a `Dispatch`
-    let no_op_dispatch = tracing::dispatcher::Dispatch::new(no_op_subscriber);
-
-    // Temporarily set `no_op_dispatch` as the *default* within this closure
-    tracing::dispatcher::with_default(&no_op_dispatch, f)
+    let no_op_subscriber = tracing_subscriber::fmt()
+        .with_writer(std::io::sink)
+        .with_max_level(tracing_subscriber::filter::LevelFilter::OFF)
+        .finish();
+    let dispatch = tracing::Dispatch::new(no_op_subscriber);
+    tracing::dispatcher::with_default(&dispatch, f)
 }

data/lib/itsi/{request.rb → http_request.rb}

@@ -4,9 +4,23 @@ require "stringio"
 require "socket"
 
 module Itsi
-  class Request
+  class HttpRequest
     attr_accessor :hijacked
 
+    EMPTY_IO = StringIO.new("").freeze
+    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
+      [header, rack_form]
+    end.to_h.tap do |hm|
+      hm.default_proc = proc { |hsh, key| "HTTP_#{key.upcase.gsub(/-/, "_")}" }
+    end
+
     def to_rack_env
       path = self.path
       host = self.host
@@ -21,8 +35,8 @@ module Itsi
         "REMOTE_ADDR" => remote_addr,
         "SERVER_PORT" => port.to_s,
         "SERVER_NAME" => host,
-        "HTTP_HOST" => host,
         "SERVER_PROTOCOL" => version,
+        "HTTP_HOST" => host,
         "HTTP_VERSION" => version,
         "itsi.request" => self,
         "itsi.response" => response,
@@ -36,17 +50,26 @@ module Itsi
         "rack.hijack?" => true,
         "rack.multipart.buffer_size" => 16_384,
         "rack.hijack" => build_hijack_proc
-      }.tap { |r| headers.each { |(k, v)| r[k] = v } }
+      }.tap do |r|
+        headers.each do |(k, v)|
+          r[RACK_HEADER_MAP[k]] = v
+        end
+      end
+    end
+
+    def respond(_body = nil, _status = 200, _header = nil, status: _status, headers: _header, body: _body,
+                hijack: false, &blk)
+      response.respond(status: status, headers: headers, body: body, hijack: hijack, &blk)
     end
 
     def build_hijack_proc
       lambda do
         self.hijacked = true
         UNIXSocket.pair.yield_self do |(server_sock, app_sock)|
+          server_sock.autoclose = false
           response.hijack(server_sock.fileno)
           server_sock.sync = true
           app_sock.sync = true
-          app_sock.instance_variable_set("@server_sock", server_sock)
           app_sock
         end
       end
@@ -54,8 +77,9 @@ module Itsi
 
     def build_input_io
       case body
-      when Array then File.open(body.first, "rb")
+      when nil then StringIO.new("")
       when String then StringIO.new(body)
+      when Array then File.open(body.first, "rb")
       else body
       end
     end

data/lib/itsi/http_response.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require 'forwardable'
+require "stringio"
+require "socket"
+
+module Itsi
+
+  class HttpResponse
+
+    def respond _body=nil, _status=200, _header=nil, status: _status, headers: _header, body: _body, hijack: false, &blk
+      self.status = status
+
+      if headers
+        headers.each do |key, value|
+          if value.is_a?(Array)
+            value.each { |v| add_header(key, v) }
+          else
+            add_header(key, value)
+          end
+        end
+      end
+
+      if body
+        # Common case. Write a single string body.
+        send_and_close(body)
+      elsif block_given?
+
+        # If you call respond with a block, you get a handle to a stream that you can write to.
+        yield self
+
+        # If you hijack the connection, you are responsible for closing it.
+        # Otherwise, the response will be closed automatically.
+        self.close unless hijack
+      else
+        self.close
+      end
+    end
+  end
+end

data/lib/itsi/server/Itsi.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-env = ENV.fetch('APP_ENV') { ENV.fetch('RACK_ENV', 'development') }
 
 # This is the default Itsi configuration file, installed when you run `itsi init`
 # It contains a sane starting point for configuring your Itsi server.
@@ -7,18 +6,20 @@ env = ENV.fetch('APP_ENV') { ENV.fetch('RACK_ENV', 'development') }
 # 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 : Etc.nprocessors
+workers ENV.fetch("ITSI_WORKERS") {
+  require "etc"
+  env == "development" ? 1 : Etc.nprocessors
 }
 
 # 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)
+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.
@@ -38,7 +39,7 @@ fiber_scheduler nil
 #   use Rack::CommonLogger
 #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
 # end)
-rackup_file 'config.ru'
+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)
@@ -57,10 +58,10 @@ rackup_file 'config.ru'
 # bind "unix:///tmp/itsi.sock"
 # bind "tls:///tmp/itsi.secure.sock"
 
-if env == 'development'
-  bind 'http://localhost:3000'
+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"
+  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
@@ -80,7 +81,7 @@ preload true
 # 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 48 * 1024 * 1024
+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.)
@@ -107,15 +108,6 @@ stream_body false
 # Setting this too low can substantially worsen performance
 oob_gc_responses_threshold 512
 
-# 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