itsi 0.1.14 → 0.1.18

data/crates/itsi_tracing/src/lib.rs

@@ -5,15 +5,34 @@ use std::{
 };
 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};
+use tracing_subscriber::{Layer, Registry, layer::Layered};
 
 // Global reload handle for changing the level at runtime.
 static RELOAD_HANDLE: OnceLock<
     Mutex<Option<reload::Handle<EnvFilter, tracing_subscriber::Registry>>>,
 > = OnceLock::new();
 
+// Global reload handle for changing the formatting layer (log target/format) at runtime.
+type ReloadFmtHandle = reload::Handle<
+    Box<
+        dyn Layer<
+                tracing_subscriber::layer::Layered<
+                    reload::Layer<EnvFilter, tracing_subscriber::Registry>,
+                    tracing_subscriber::Registry,
+                >,
+            > + Send
+            + Sync,
+    >,
+    Layered<tracing_subscriber::reload::Layer<EnvFilter, Registry>, Registry>,
+>;
+
+static RELOAD_FMT_HANDLE: OnceLock<Mutex<Option<ReloadFmtHandle>>> = OnceLock::new();
+
+// Global current log configuration for formatting options.
+static CURRENT_CONFIG: OnceLock<Mutex<LogConfig>> = OnceLock::new();
+
 /// Log format: Plain or JSON.
 #[derive(Debug, Clone)]
 pub enum LogFormat {
@@ -73,18 +92,19 @@ impl Default for LogConfig {
     }
 }
 
-/// Initialize the global tracing subscriber with the default configuration.
-pub fn 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 {
+/// Build the formatting layer based on the provided configuration.
+fn build_fmt_layer(
+    config: &LogConfig,
+) -> Box<
+    dyn Layer<
+            tracing_subscriber::layer::Layered<
+                reload::Layer<EnvFilter, tracing_subscriber::Registry>,
+                tracing_subscriber::Registry,
+            >,
+        > + Send
+        + Sync,
+> {
+    match &config.target {
         LogTarget::Stdout => match config.format {
             LogFormat::Plain => fmt::layer()
                 .compact()
@@ -106,35 +126,39 @@ pub fn init_with_config(config: LogConfig) {
                 .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::File(file) => {
+            let file_clone = file.clone();
+            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(move || {
+                        rolling::daily(".", file_clone.clone())
+                    }))
+                    .with_ansi(false)
+                    .boxed(),
+                LogFormat::Json => {
+                    let file_clone = file.clone();
+                    fmt::layer()
+                        .compact()
+                        .with_file(false)
+                        .with_line_number(false)
+                        .with_target(false)
+                        .with_thread_ids(false)
+                        .with_writer(BoxMakeWriter::new(move || {
+                            rolling::daily(".", file_clone.clone())
+                        }))
+                        .with_ansi(false)
+                        .json()
+                        .boxed()
+                }
+            }
+        }
         LogTarget::Both(file) => {
-            // For "Both" target, handle each format separately to avoid type mismatches
+            let file_clone = file.clone();
             match config.format {
                 LogFormat::Plain => {
                     let stdout_layer = fmt::layer()
@@ -145,19 +169,16 @@ pub fn init_with_config(config: LogConfig) {
                         .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_writer(BoxMakeWriter::new(move || {
+                            rolling::daily(".", file_clone.clone())
                         }))
                         .with_ansi(false);
-
                     stdout_layer.and_then(file_layer).boxed()
                 }
                 LogFormat::Json => {
@@ -170,30 +191,61 @@ pub fn init_with_config(config: LogConfig) {
                         .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_writer(BoxMakeWriter::new(move || {
+                            rolling::daily(".", file_clone.clone())
                         }))
                         .with_ansi(false)
                         .json();
-
                     stdout_layer.and_then(file_layer).boxed()
                 }
             }
         }
-    };
+    }
+}
+
+/// Update the formatting layer using the current configuration.
+fn update_fmt_layer(config: &LogConfig) {
+    if let Some(handle) = RELOAD_FMT_HANDLE.get().unwrap().lock().unwrap().as_ref() {
+        let new_layer = build_fmt_layer(config);
+        handle
+            .modify(|layer| {
+                *layer = new_layer;
+            })
+            .expect("Failed to update formatting layer");
+    } else {
+        eprintln!("Reload handle for formatting layer not initialized; call init() first.");
+    }
+}
+
+/// Initialize the global tracing subscriber with the default configuration.
+pub fn init() {
+    init_with_config(LogConfig::default());
+}
+
+/// Initialize the global tracing subscriber with a given configuration.
+pub fn init_with_config(config: LogConfig) {
+    // Store the current config in a global for future updates.
+    CURRENT_CONFIG.set(Mutex::new(config.clone())).ok();
+
+    // Build an EnvFilter from the configured level.
+    let env_filter = EnvFilter::new(config.clone().level);
+
+    // Build the formatting layer based on the configuration.
+    let fmt_layer = build_fmt_layer(&config);
 
     // Create a reloadable filter layer so we can update the level at runtime.
-    let (filter_layer, handle) = reload::Layer::new(env_filter);
+    let (filter_layer, filter_handle) = reload::Layer::new(env_filter);
+
+    // Create a reloadable formatting layer so we can update the target/format at runtime.
+    let (fmt_layer, fmt_handle) = reload::Layer::new(fmt_layer);
 
-    // Build the subscriber registry
+    // Build the subscriber registry.
     let subscriber = tracing_subscriber::registry()
         .with(filter_layer)
         .with(fmt_layer);
@@ -201,7 +253,8 @@ pub fn init_with_config(config: LogConfig) {
     tracing::subscriber::set_global_default(subscriber)
         .expect("Unable to set global tracing subscriber");
 
-    RELOAD_HANDLE.set(Mutex::new(Some(handle))).unwrap();
+    RELOAD_HANDLE.set(Mutex::new(Some(filter_handle))).unwrap();
+    RELOAD_FMT_HANDLE.set(Mutex::new(Some(fmt_handle))).ok();
 }
 
 /// Change the log level at runtime.
@@ -210,11 +263,48 @@ pub fn set_level(new_level: &str) {
         handle
             .modify(|filter| *filter = EnvFilter::new(new_level))
             .expect("Failed to update log level");
+
+        // Also update the stored config.
+        if let Some(config_mutex) = CURRENT_CONFIG.get() {
+            let mut config = config_mutex.lock().unwrap();
+            config.level = new_level.to_string();
+        }
     } else {
         eprintln!("Reload handle not initialized; call init() first.");
     }
 }
 
+/// Change the log target at runtime.
+pub fn set_target(new_target: &str) {
+    let target: LogTarget = match new_target {
+        "stdout" => LogTarget::Stdout,
+        path => LogTarget::File(path.to_string()),
+    };
+    if let Some(config_mutex) = CURRENT_CONFIG.get() {
+        let mut config = config_mutex.lock().unwrap();
+        config.target = target;
+        update_fmt_layer(&config);
+    } else {
+        eprintln!("Current configuration not initialized; call init() first.");
+    }
+}
+
+/// Change the log format at runtime.
+pub fn set_format(new_format: &str) {
+    let format = match new_format {
+        "json" => LogFormat::Json,
+        "plain" => LogFormat::Plain,
+        _ => LogFormat::Json,
+    };
+    if let Some(config_mutex) = CURRENT_CONFIG.get() {
+        let mut config = config_mutex.lock().unwrap();
+        config.format = format;
+        update_fmt_layer(&config);
+    } else {
+        eprintln!("Current configuration 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

data/{Itsi.rb → foo/Itsi.rb}

@@ -1,4 +1,5 @@
 # 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.
@@ -11,14 +12,14 @@ env = ENV.fetch("APP_ENV") { ENV.fetch("RACK_ENV", "development") }
 # If more than 1, Itsi will be booted in Cluster mode
 workers ENV.fetch("ITSI_WORKERS") {
   require "etc"
-  env == "development" ? 1 : Etc.nprocessors
+  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", 1)
+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.
@@ -40,13 +41,9 @@ fiber_scheduler nil
 # end)
 # rackup_file "config.ru"
 
-watch "*.rb", [%w[bundle exec itsi reload]]
-location "/*" do
-  get "" do |req|
-    req.respond("Hello")
-  end
+endpoint do |req|
+  req.respond("Im Itsi")
 end
-# run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
 # 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"
@@ -65,7 +62,7 @@ end
 # bind "tls:///tmp/itsi.secure.sock"
 
 if env == "development"
-  bind "http://127.0.0.1:3001"
+  bind "http://localhost:3000"
 else
   bind "https://0.0.0.0?domains=#{ENV["PRODUCTION_DOMAINS"]}&cert=acme&acme_email=admin@itsi.fyi"
 end

data/gems/scheduler/Cargo.lock

@@ -11,6 +11,12 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "anyhow"
+version = "1.0.97"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
+
 [[package]]
 name = "atty"
 version = "0.2.14"
@@ -227,6 +233,7 @@ dependencies = [
 name = "itsi_error"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
  "httparse",
  "magnus",
  "nix",

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

@@ -2,6 +2,6 @@
 
 module Itsi
   class Scheduler
-    VERSION = "0.1.14"
+    VERSION = "0.1.18"
   end
 end

data/gems/scheduler/test/helpers/test_helper.rb

@@ -4,7 +4,6 @@ require "minitest/reporters"
 Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
 
 require "itsi/scheduler"
-require 'debug'
 module Itsi::Scheduler::TestHelper
   SchedulerClass = Itsi::Scheduler
 

data/gems/scheduler/test/test_address_resolve.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require 'debug'
 
 class TestAddressResolve < Minitest::Test
   include Itsi::Scheduler::TestHelper

data/gems/scheduler/test/test_network_io.rb

@@ -2,7 +2,7 @@
 
 require "socket"
 require "timeout"
-require "debug"
+
 
 class TestNetworkIO < Minitest::Test
   include Itsi::Scheduler::TestHelper

data/gems/scheduler/test/test_process_wait.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require 'debug'
 
 
 class TestProcessWait < Minitest::Test