itsi-server 0.1.1 → 0.1.18

data/ext/itsi_tracing/Cargo.toml

@@ -9,4 +9,9 @@ tracing-subscriber = { version = "0.3.19", features = [
   "env-filter",
   "std",
   "fmt",
+  "json",
+  "ansi",
 ] }
+tracing-attributes = "0.1"
+atty = "0.2.14"
+tracing-appender = "0.2.3"

data/ext/itsi_tracing/src/lib.rs

@@ -1,11 +1,319 @@
+use atty::{Stream, is};
+use std::{
+    env,
+    sync::{Mutex, OnceLock},
+};
 pub use tracing::{debug, error, info, trace, warn};
-use tracing_subscriber::{EnvFilter, fmt};
+use tracing_appender::rolling;
+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 {
+    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,
+}
+
+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,
+        }
+    }
+}
+
+/// 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()
+                .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) => {
+            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) => {
+            let file_clone = file.clone();
+            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(move || {
+                            rolling::daily(".", file_clone.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(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() {
-    let env_filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
-    let format = fmt::format().with_level(true).with_target(false).compact();
-    tracing_subscriber::fmt()
-        .with_env_filter(env_filter)
-        .event_format(format)
-        .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, 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.
+    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(filter_handle))).unwrap();
+    RELOAD_FMT_HANDLE.set(Mutex::new(Some(fmt_handle))).ok();
+}
+
+/// 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");
+
+        // 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
+    F: FnOnce() -> R,
+{
+    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/http_request/response_status_shortcodes.rb

@@ -0,0 +1,74 @@
+module Itsi
+  class HttpRequest
+    module ResponseStatusShortcodes
+
+      HTTP_STATUS_CODES = {
+        100 => :continue,
+        101 => :switching_protocols,
+        102 => :processing,
+        200 => :ok,
+        201 => :created,
+        202 => :accepted,
+        203 => :non_authoritative_information,
+        204 => :no_content,
+        205 => :reset_content,
+        206 => :partial_content,
+        207 => :multi_status,
+        208 => :already_reported,
+        226 => :im_used,
+        300 => :multiple_choices,
+        301 => :moved_permanently,
+        302 => :found,
+        303 => :see_other,
+        304 => :not_modified,
+        305 => :use_proxy,
+        307 => :temporary_redirect,
+        308 => :permanent_redirect,
+        400 => :bad_request,
+        401 => :unauthorized,
+        402 => :payment_required,
+        403 => :forbidden,
+        404 => :not_found,
+        405 => :method_not_allowed,
+        406 => :not_acceptable,
+        407 => :proxy_authentication_required,
+        408 => :request_timeout,
+        409 => :conflict,
+        410 => :gone,
+        411 => :length_required,
+        412 => :precondition_failed,
+        413 => :payload_too_large,
+        414 => :uri_too_long,
+        415 => :unsupported_media_type,
+        416 => :range_not_satisfiable,
+        417 => :expectation_failed,
+        418 => :im_a_teapot,
+        421 => :misdirected_request,
+        422 => :unprocessable_entity,
+        423 => :locked,
+        424 => :failed_dependency,
+        425 => :too_early,
+        426 => :upgrade_required,
+        428 => :precondition_required,
+        429 => :too_many_requests,
+        431 => :request_header_fields_too_large,
+        451 => :unavailable_for_legal_reasons,
+        500 => :internal_server_error,
+        501 => :not_implemented,
+        502 => :bad_gateway,
+        503 => :service_unavailable,
+        504 => :gateway_timeout,
+        505 => :http_version_not_supported,
+        506 => :variant_also_negotiates,
+        507 => :insufficient_storage,
+        508 => :loop_detected,
+        510 => :not_extended,
+        511 => :network_authentication_required
+      }.freeze
+
+      HTTP_STATUS_CODES.each do |code, name|
+        define_method(name) {|*args, **kwargs| respond(*args, **kwargs, status: code) }
+      end
+    end
+  end
+end

data/lib/itsi/http_request.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "socket"
+require "uri"
+require_relative 'http_request/response_status_shortcodes'
+
+module Itsi
+  class HttpRequest
+    include Server::TypedHandlers::ParamParser
+    include ResponseStatusShortcodes
+    attr_accessor :hijacked
+
+    EMPTY_IO = StringIO.new("")
+    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
+      version = self.version
+      {
+        "SERVER_SOFTWARE" => "Itsi",
+        "SCRIPT_NAME" => script_name,
+        "REQUEST_METHOD" => request_method,
+        "PATH_INFO" => path,
+        "REQUEST_PATH" => path,
+        "QUERY_STRING" => query_string,
+        "REMOTE_ADDR" => remote_addr,
+        "SERVER_PORT" => port.to_s,
+        "SERVER_NAME" => host,
+        "SERVER_PROTOCOL" => version,
+        "HTTP_HOST" => host,
+        "HTTP_VERSION" => version,
+        "itsi.request" => self,
+        "itsi.response" => response,
+        "rack.version" => [version],
+        "rack.url_scheme" => scheme,
+        "rack.input" => build_input_io,
+        "rack.errors" => $stderr,
+        "rack.multithread" => true,
+        "rack.multiprocess" => true,
+        "rack.run_once" => false,
+        "rack.hijack?" => true,
+        "rack.multipart.buffer_size" => 16_384,
+        "rack.hijack" => method(:hijack)
+      }.tap do |r|
+        headers.each do |(k, v)|
+          r[case k
+            when "content-type" then "CONTENT_TYPE"
+            when "content-length" then "CONTENT_LENGTH"
+            when "accept" then "HTTP_ACCEPT"
+            when "accept-encoding" then "HTTP_ACCEPT_ENCODING"
+            when "accept-language" then "HTTP_ACCEPT_LANGUAGE"
+            when "user-agent" then "HTTP_USER_AGENT"
+            when "referer" then "HTTP_REFERER"
+            when "origin" then "HTTP_ORIGIN"
+            when "cookie" then "HTTP_COOKIE"
+            when "authorization" then "HTTP_AUTHORIZATION"
+            when "x-forwarded-for" then "HTTP_X_FORWARDED_FOR"
+            when "x-forwarded-proto" then "HTTP_X_FORWARDED_PROTO"
+            else RACK_HEADER_MAP[k]
+            end
+          ] = v
+        end
+      end
+    end
+
+    def respond(
+      _body = nil, _status = 200, _headers = nil,
+      json: nil,
+      html: nil,
+      text: nil,
+      xml: nil,
+      hijack: false,
+      as: nil,
+      status: _status,
+      headers: _headers,
+      body: _body,
+      &blk
+    )
+
+      if json
+        validate!(json, as: as) if as
+        body = json.to_json
+        headers ||= {}
+        headers["Content-Type"] ||= "application/json"
+      elsif html
+        body = html
+        headers ||= {}
+        headers["Content-Type"] ||= "text/html"
+      elsif xml
+        body = xml
+        headers ||= {}
+        headers["Content-Type"] ||= "application/xml"
+      elsif text
+        body = text
+        headers ||= {}
+        headers["Content-Type"] ||= "text/plain"
+      end
+
+      response.respond(status: status, headers: headers, body: body, hijack: hijack, &blk)
+    end
+
+    def hijack
+      self.hijacked = true
+      UNIXSocket.pair.yield_self do |(server_sock, app_sock)|
+        server_sock.autoclose = false
+        self.response.hijack(server_sock.fileno)
+        server_sock.sync = true
+        app_sock.sync = true
+        app_sock
+      end
+    end
+
+    def build_input_io
+      case body
+      when nil then EMPTY_IO
+      when String then StringIO.new(body)
+      when Array then File.open(body.first, "rb")
+      else body
+      end
+    end
+
+    def validate!(params, as: nil)
+      as ? apply_schema!(params, as) : params
+    end
+
+    def params(schema=nil)
+      params = case
+      when url_encoded? then URI.decode_www_form(build_input_io.read).to_h
+      when json? then JSON.parse(build_input_io.read)
+      when multipart?
+        Rack::Multipart::Parser.parse(
+          build_input_io,
+          content_length,
+          content_type,
+          Rack::Multipart::Parser::TEMPFILE_FACTORY,
+          Rack::Multipart::Parser::BUFSIZE,
+          Rack::Utils.default_query_parser
+        ).params
+      else
+        {}
+      end
+
+      params.merge!(query_params).merge!(url_params)
+
+      yield schema ? apply_schema!(params, schema) : params
+
+    rescue StandardError => e
+      if response.json?
+        respond(json: {error: e.message}, status: 400)
+      else
+        respond(e.message, 400)
+      end
+    ensure
+      clean_temp_files(params)
+    end
+
+    def clean_temp_files(params)
+      case params
+      when Hash
+        if params.key?(:tempfile)
+          params[:tempfile].unlink
+        else
+        params.each_value { |v| clean_temp_files(v) }
+        end
+      when Array then params.each { |v| clean_temp_files(v) }
+      end
+    end
+
+    def query_params
+      URI.decode_www_form(query_string).to_h
+    end
+  end
+end

data/lib/itsi/http_response.rb

@@ -0,0 +1,41 @@
+# 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
+
+      body = body.to_s unless body.is_a?(String)
+
+      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