kino 0.3.0 → 0.5.0

data/ext/kino/src/server.rs

@@ -2,7 +2,7 @@
 //! intake. Ruby is never on these threads; the only contact points are the
 //! flume queue (in) and each request's Responder (out).
 
-use std::net::SocketAddr;
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::time::Duration;
@@ -13,7 +13,8 @@ use hyper_util::rt::TokioIo;
 use magnus::{Error, Ruby};
 use parking_lot::{Mutex, RwLock};
 
-use crate::registry::{self, BoxedCtx, ServerInner, WorkerSlot};
+use crate::listen::Listener;
+use crate::registry::{self, BoxedCtx, RuntimeHandle, ServerInner, WorkerSlot};
 use crate::request::RequestCtx;
 use crate::response::{plain_response, HyperResponse, Responder};
 
@@ -55,6 +56,8 @@ pub fn server_start(ruby: &Ruby, config: magnus::RHash) -> Result<(u64, u16, Opt
     let request_timeout_ms: u64 = cfg_opt::<u64>(ruby, config, "request_timeout_ms")?.unwrap_or(0);
     let max_body_size: usize = cfg_opt::<usize>(ruby, config, "max_body_size")?.unwrap_or(0);
     let max_connections: usize = cfg_opt::<usize>(ruby, config, "max_connections")?.unwrap_or(1024);
+    let io_shards: bool = cfg_opt(ruby, config, "io_shards")?.unwrap_or(false);
+    let io_threads: usize = cfg_opt::<usize>(ruby, config, "io_threads")?.unwrap_or(0);
     let tokio_threads: usize = cfg_opt::<usize>(ruby, config, "tokio_threads")?.unwrap_or(0);
     let tls_cert: Option<String> = cfg_opt(ruby, config, "tls_cert")?;
     let tls_key: Option<String> = cfg_opt(ruby, config, "tls_key")?;
@@ -78,15 +81,22 @@ pub fn server_start(ruby: &Ruby, config: magnus::RHash) -> Result<(u64, u16, Opt
         }
     };
 
-    let listener = std::net::TcpListener::bind((bind.as_str(), port))
-        .map_err(|e| io_error(ruby, "bind failed", e))?;
-    listener
-        .set_nonblocking(true)
-        .map_err(|e| io_error(ruby, "listener setup failed", e))?;
+    let listener = Listener::bind(&bind, port).map_err(|e| io_error(ruby, "bind failed", e))?;
+    // Ruby refuses this combination up front; this guards embedders
+    // calling the native layer directly.
+    if acceptor.is_some() && matches!(listener, Listener::Unix(..)) {
+        return Err(Error::new(
+            ruby.exception_arg_error(),
+            "TLS is not supported on a unix socket bind",
+        ));
+    }
     let local_port = listener
-        .local_addr()
-        .map_err(|e| io_error(ruby, "listener setup failed", e))?
-        .port();
+        .port()
+        .map_err(|e| io_error(ruby, "listener setup failed", e))?;
+    let unix_path = match &listener {
+        Listener::Unix(_, path) => Some(path.clone()),
+        Listener::Tcp(_) => None,
+    };
 
     let control_bind_addr: Option<String> = cfg_opt(ruby, config, "control_bind")?;
     let control_token: Option<String> = cfg_opt(ruby, config, "control_token")?;
@@ -97,15 +107,6 @@ pub fn server_start(ruby: &Ruby, config: magnus::RHash) -> Result<(u64, u16, Opt
         })
         .transpose()?;
 
-    let mut builder = tokio::runtime::Builder::new_multi_thread();
-    builder.enable_all().thread_name("kino-tokio");
-    if tokio_threads > 0 {
-        builder.worker_threads(tokio_threads);
-    }
-    let runtime = builder
-        .build()
-        .map_err(|e| io_error(ruby, "tokio runtime failed", e))?;
-
     let (req_tx, req_rx) = flume::bounded(queue_depth);
     let (shutdown_tx, shutdown_rx) = tokio::sync::watch::channel(false);
 
@@ -114,7 +115,7 @@ pub fn server_start(ruby: &Ruby, config: magnus::RHash) -> Result<(u64, u16, Opt
         req_tx: Mutex::new(Some(req_tx)),
         req_rx,
         shutdown_tx,
-        runtime: Mutex::new(None),
+        runtime: Mutex::new(RuntimeHandle::None),
         slots: RwLock::new(Vec::new()),
         in_flight: std::sync::atomic::AtomicUsize::new(0),
         served: std::sync::atomic::AtomicU64::new(0),
@@ -126,8 +127,14 @@ pub fn server_start(ruby: &Ruby, config: magnus::RHash) -> Result<(u64, u16, Opt
         state: std::sync::atomic::AtomicU8::new(registry::STATE_BOOTING),
         respawns: std::sync::atomic::AtomicU64::new(0),
         quarantine_replacements: std::sync::atomic::AtomicU64::new(0),
-        topology: registry::Topology { mode, workers, threads, batch },
+        topology: registry::Topology {
+            mode,
+            workers,
+            threads,
+            batch,
+        },
         https: acceptor.is_some(),
+        unix_path,
         access_log: log_requests.then(|| crate::logsink::Sink::new(std::io::stdout())),
         lanes,
         lane_cursor: std::sync::atomic::AtomicUsize::new(0),
@@ -135,19 +142,48 @@ pub fn server_start(ruby: &Ruby, config: magnus::RHash) -> Result<(u64, u16, Opt
         queue_histogram: registry::QueueHistogram::new(),
     });
 
-    let tokio_listener = {
-        let _guard = runtime.enter();
-        tokio::net::TcpListener::from_std(listener)
-            .map_err(|e| io_error(ruby, "listener setup failed", e))?
-    };
-    runtime.spawn(accept_loop(
-        tokio_listener,
-        acceptor,
-        server.clone(),
-        max_connections,
-        shutdown_rx,
-    ));
-    *server.runtime.lock() = Some(runtime);
+    if io_shards {
+        // The shards keep serving accepted connections while the acceptor
+        // drains on `shutdown_rx`; this second signal stops them only at
+        // final teardown.
+        let (runtime_shutdown_tx, runtime_shutdown_rx) = tokio::sync::watch::channel(false);
+        let threads = crate::io_shards::spawn(
+            listener,
+            acceptor,
+            server.clone(),
+            max_connections,
+            shutdown_rx,
+            runtime_shutdown_rx,
+            crate::io_shards::thread_count(io_threads),
+        )
+        .map_err(|e| io_error(ruby, "sharded runtime failed", e))?;
+        *server.runtime.lock() = RuntimeHandle::Shards {
+            shutdown_tx: runtime_shutdown_tx,
+            threads,
+        };
+    } else {
+        let mut builder = tokio::runtime::Builder::new_multi_thread();
+        builder.enable_all().thread_name("kino-tokio");
+        if tokio_threads > 0 {
+            builder.worker_threads(tokio_threads);
+        }
+        let runtime = builder
+            .build()
+            .map_err(|e| io_error(ruby, "tokio runtime failed", e))?;
+        let tokio_listener = {
+            let _guard = runtime.enter();
+            AsyncListener::from_std(listener)
+                .map_err(|e| io_error(ruby, "listener setup failed", e))?
+        };
+        runtime.spawn(accept_loop(
+            tokio_listener,
+            acceptor,
+            server.clone(),
+            max_connections,
+            shutdown_rx,
+        ));
+        *server.runtime.lock() = RuntimeHandle::MultiThread(runtime);
+    }
 
     let id = server.id;
     let control_port = match control_bind {
@@ -161,10 +197,11 @@ pub fn server_start(ruby: &Ruby, config: magnus::RHash) -> Result<(u64, u16, Opt
         Some(bind) => match crate::control::start(bind, server.clone(), control_token) {
             Ok(port) => port,
             Err(e) => {
-                // A plain drop blocks until the accept loop's task (its
-                // only task, idling on accept/shutdown) is torn down; the
-                // runtime only ever had this one thing to cancel.
-                drop(server.runtime.lock().take());
+                // Nothing is serving yet, so the bound only matters for a
+                // wedged shard thread; the default runtime just cancels
+                // its one idle accept task.
+                let _ = server.shutdown_tx.send(true);
+                std::mem::take(&mut *server.runtime.lock()).shutdown(Duration::from_millis(1_000));
                 return Err(io_error(ruby, "control start failed", e));
             }
         },
@@ -182,8 +219,61 @@ pub fn server_start(ruby: &Ruby, config: magnus::RHash) -> Result<(u64, u16, Opt
 /// timeout: not a knob.
 const TLS_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(10);
 
+/// What a unix-socket connection reports as its addresses. The peer is
+/// local by definition (REMOTE_ADDR 127.0.0.1), and a socket has no port,
+/// so SERVER_PORT falls back to http's default when the Host header names
+/// none, the way Puma reports unix-socket requests.
+const UNIX_PEER: SocketAddr = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 0);
+const UNIX_LOCAL: SocketAddr = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 80);
+
+/// The accept loop's listener: TCP (optionally behind TLS), or a unix
+/// socket, which carries plain HTTP only.
+pub(crate) enum AsyncListener {
+    Tcp(tokio::net::TcpListener),
+    Unix(tokio::net::UnixListener),
+}
+
+/// One accepted connection, before the protocol layer sees it.
+pub(crate) enum Conn {
+    Tcp(tokio::net::TcpStream),
+    Unix(tokio::net::UnixStream),
+}
+
+impl AsyncListener {
+    /// Register the bound listener with the current runtime.
+    pub(crate) fn from_std(listener: Listener) -> std::io::Result<AsyncListener> {
+        Ok(match listener {
+            Listener::Tcp(listener) => {
+                AsyncListener::Tcp(tokio::net::TcpListener::from_std(listener)?)
+            }
+            Listener::Unix(listener, _) => {
+                AsyncListener::Unix(tokio::net::UnixListener::from_std(listener)?)
+            }
+        })
+    }
+
+    /// The next connection with its (peer, local) addresses.
+    pub(crate) async fn accept(&self) -> std::io::Result<(Conn, SocketAddr, SocketAddr)> {
+        match self {
+            AsyncListener::Tcp(listener) => {
+                let (stream, remote_addr) = listener.accept().await?;
+                // Small responses must not wait on Nagle + delayed ACK.
+                let _ = stream.set_nodelay(true);
+                let local_addr = stream
+                    .local_addr()
+                    .unwrap_or_else(|_| SocketAddr::from(([0, 0, 0, 0], 0)));
+                Ok((Conn::Tcp(stream), remote_addr, local_addr))
+            }
+            AsyncListener::Unix(listener) => {
+                let (stream, _) = listener.accept().await?;
+                Ok((Conn::Unix(stream), UNIX_PEER, UNIX_LOCAL))
+            }
+        }
+    }
+}
+
 async fn accept_loop(
-    listener: tokio::net::TcpListener,
+    listener: AsyncListener,
     acceptor: Option<tokio_rustls::TlsAcceptor>,
     server: Arc<ServerInner>,
     max_connections: usize,
@@ -202,38 +292,50 @@ async fn accept_loop(
                 Err(_) => break, // semaphore closed
             },
         };
-        let (stream, remote_addr) = tokio::select! {
+        let (conn, remote_addr, local_addr) = tokio::select! {
             _ = shutdown_rx.changed() => break,
             accepted = listener.accept() => match accepted {
-                Ok(pair) => pair,
+                Ok(accepted) => accepted,
                 Err(_) => continue, // transient accept error; permit drops, retry
             },
         };
-        // Small responses must not wait on Nagle + delayed ACK.
-        let _ = stream.set_nodelay(true);
-        let local_addr = stream
-            .local_addr()
-            .unwrap_or_else(|_| SocketAddr::from(([0, 0, 0, 0], 0)));
         let server = server.clone();
         let acceptor = acceptor.clone();
         tokio::spawn(async move {
             // Held for the connection's lifetime; dropping it frees a slot.
             let _permit = permit;
-            match acceptor {
-                Some(acceptor) => {
-                    // Handshake failures (port scans, plain HTTP to a TLS
-                    // port) and stalled handshakes (slowloris) just drop the
-                    // connection; the timeout bounds the latter.
-                    let handshake = tokio::time::timeout(TLS_HANDSHAKE_TIMEOUT, acceptor.accept(stream));
-                    let Ok(Ok(tls)) = handshake.await else { return };
-                    serve_connection(tls, server, remote_addr, local_addr).await;
-                }
-                None => serve_connection(stream, server, remote_addr, local_addr).await,
-            }
+            serve_conn(conn, acceptor, server, remote_addr, local_addr).await;
         });
     }
 }
 
+/// Everything between an accepted connection and hyper: the optional TLS
+/// handshake, then the protocol layer. Shared by the default accept loop
+/// and the sharded one, so connection policy exists exactly once.
+pub(crate) async fn serve_conn(
+    conn: Conn,
+    acceptor: Option<tokio_rustls::TlsAcceptor>,
+    server: Arc<ServerInner>,
+    remote_addr: SocketAddr,
+    local_addr: SocketAddr,
+) {
+    match (conn, acceptor) {
+        (Conn::Tcp(stream), Some(acceptor)) => {
+            // Handshake failures (port scans, plain HTTP to a TLS
+            // port) and stalled handshakes (slowloris) just drop the
+            // connection; the timeout bounds the latter.
+            let handshake = tokio::time::timeout(TLS_HANDSHAKE_TIMEOUT, acceptor.accept(stream));
+            let Ok(Ok(tls)) = handshake.await else { return };
+            serve_connection(tls, server, remote_addr, local_addr).await;
+        }
+        (Conn::Tcp(stream), None) => {
+            serve_connection(stream, server, remote_addr, local_addr).await
+        }
+        // TLS over a unix socket is refused at bind time.
+        (Conn::Unix(stream), _) => serve_connection(stream, server, remote_addr, local_addr).await,
+    }
+}
+
 /// Slowloris guard: drop a connection that has not sent its complete request
 /// headers within this window. Long enough never to trip a real client (even
 /// on a slow mobile link), short enough to reap a stalled one. Deliberately a
@@ -310,18 +412,21 @@ async fn handle_request(
     let (parts, body) = req.into_parts();
 
     // Access-log metadata is captured only when logging is on: one Instant
-    // read plus one small String per request.
-    let log_meta = server.access_log.as_ref().map(|_| {
+    // read plus two small Strings per request. The arrival record is
+    // queued now, before the app sees the request, so a hang shows as an
+    // arrow with no answer; the completion record follows the response.
+    let log_meta = server.access_log.as_ref().map(|log| {
         let target = match parts.uri.query() {
             Some(q) => format!("{}?{}", parts.uri.path(), q),
             None => parts.uri.path().to_string(),
         };
-        (
-            std::time::Instant::now(),
-            parts.method.to_string(),
-            target,
-            parts.version,
-        )
+        let method = parts.method.to_string();
+        log.write_line(crate::access_log::arrival(
+            &method,
+            &target,
+            remote_addr.ip(),
+        ));
+        (std::time::Instant::now(), method, target)
     });
 
     // Body-size guard: an honestly-declared oversize body is refused with a
@@ -378,6 +483,7 @@ async fn handle_request(
 
     let (head_tx, head_rx) = tokio::sync::oneshot::channel();
     let responder = Arc::new(Responder::new(head_tx));
+    let now = std::time::Instant::now();
     let ctx = Box::new(RequestCtx {
         method: parts.method,
         uri: parts.uri,
@@ -393,7 +499,11 @@ async fn handle_request(
         slot: None,
         pin_slab: server.pin_slab.clone(),
         responder,
-        enqueued_at: std::time::Instant::now(),
+        enqueued_at: now,
+        timed: server.access_log.is_some(),
+        wait: Duration::ZERO,
+        admitted_at: now,
+        gc: None,
     });
 
     // Drop guard, not manual decrement: when a client aborts mid-request,
@@ -472,17 +582,20 @@ async fn handle_request(
         }
     };
 
-    if let (Some(log), Some((start, method, target, version))) =
-        (server.access_log.as_ref(), log_meta)
-    {
-        let status = response.status().as_u16();
-        let line = format!(
-            "{} [{}] \"{method} {target} {version:?}\" {status} {:.1}ms",
-            remote_addr.ip(),
-            httpdate::fmt_http_date(std::time::SystemTime::now()),
-            start.elapsed().as_secs_f64() * 1000.0
-        );
-        log.write_line(crate::style::status_colored(status, &line));
+    if let (Some(log), Some((start, method, target))) = (server.access_log.as_ref(), log_meta) {
+        // The worker attached its timing to the response head; a 503 or
+        // 504 never reached a worker and carries none.
+        let timing = response
+            .extensions()
+            .get::<crate::access_log::Timing>()
+            .copied();
+        log.write_line(crate::access_log::completion(
+            response.status().as_u16(),
+            &method,
+            &target,
+            start.elapsed(),
+            timing,
+        ));
     }
 
     Ok(branded(response))
@@ -559,7 +672,9 @@ pub fn register_worker(ruby: &Ruby, server_id: u64) -> Result<usize, Error> {
 
 pub fn stop_accepting(_ruby: &Ruby, server_id: u64) -> Result<(), Error> {
     if let Some(server) = registry::try_get(server_id) {
-        server.state.store(registry::STATE_DRAINING, Ordering::Relaxed);
+        server
+            .state
+            .store(registry::STATE_DRAINING, Ordering::Relaxed);
         let _ = server.shutdown_tx.send(true);
     }
     Ok(())
@@ -648,8 +763,11 @@ pub fn interrupt_all_workers(_ruby: &Ruby, server_id: u64) -> Result<(), Error>
 
 pub fn shutdown_runtime(_ruby: &Ruby, server_id: u64, timeout_ms: u64) -> Result<(), Error> {
     if let Some(server) = registry::remove(server_id) {
-        if let Some(runtime) = server.runtime.lock().take() {
-            runtime.shutdown_timeout(Duration::from_millis(timeout_ms));
+        let _ = server.shutdown_tx.send(true);
+        std::mem::take(&mut *server.runtime.lock()).shutdown(Duration::from_millis(timeout_ms));
+        // The listener is closed with the runtime; its socket file is not.
+        if let Some(path) = &server.unix_path {
+            crate::listen::cleanup_unix(path);
         }
     }
     Ok(())
@@ -665,12 +783,6 @@ pub fn pin_keeper(
     Ok(ruby.obj_wrap(crate::pin::PinKeeper(server.pin_slab.clone())))
 }
 
-/// Errors print in red on color terminals. Covers worker errors,
-/// supervisor crash reports, and everything apps write to rack.errors.
-pub fn log_error(message: String) {
-    eprintln!("{}", crate::style::red(&format!("[Kino] {message}")));
-}
-
 /// Full stats snapshot: [queued, in_flight, served, rejected, timeouts,
 /// respawns, lane_depths]. lane_depths is nil unless lane dispatch is on.
 #[allow(clippy::type_complexity)]
@@ -709,10 +821,7 @@ pub type WorkerStatRow = (usize, u64, usize, u64, bool);
 
 /// Per-slot rows for Server#stats parity: [index, served, in_flight,
 /// busy_ms, quarantined] each. Empty when the server is gone.
-pub fn worker_stats(
-    _ruby: &Ruby,
-    server_id: u64,
-) -> Result<Vec<WorkerStatRow>, Error> {
+pub fn worker_stats(_ruby: &Ruby, server_id: u64) -> Result<Vec<WorkerStatRow>, Error> {
     let Some(server) = registry::try_get(server_id) else {
         return Ok(Vec::new());
     };
@@ -734,7 +843,9 @@ pub fn quarantine_slot(ruby: &Ruby, server_id: u64, worker_id: usize) -> Result<
 /// One replacement spawned by the quarantine monitor.
 pub fn record_quarantine_replacement(_ruby: &Ruby, server_id: u64) -> Result<(), Error> {
     if let Some(server) = registry::try_get(server_id) {
-        server.quarantine_replacements.fetch_add(1, Ordering::Relaxed);
+        server
+            .quarantine_replacements
+            .fetch_add(1, Ordering::Relaxed);
     }
     Ok(())
 }
@@ -785,7 +896,10 @@ mod tests {
         server.register_worker();
         server.slots.read()[0].lane_tx.lock().take();
 
-        assert!(matches!(try_dispatch(&server, test_ctx()), Dispatch::Closed));
+        assert!(matches!(
+            try_dispatch(&server, test_ctx()),
+            Dispatch::Closed
+        ));
     }
 
     #[test]
@@ -828,9 +942,7 @@ mod tests {
         let server = test_server(true, 4);
         server.register_worker();
         server.register_worker();
-        server.slots.read()[0]
-            .parked
-            .store(true, Ordering::Relaxed);
+        server.slots.read()[0].parked.store(true, Ordering::Relaxed);
 
         // Both dispatches land on the awake lane (slot 1), regardless of
         // where the rotating cursor starts.

data/ext/kino/src/style.rs

@@ -1,18 +1,19 @@
-//! ANSI styling for the few places the native layer writes to the
-//! terminal: stderr error lines and the stdout access log. (The Ruby-side
-//! startup banner has its own twin in Kino::CLI.) Color-capability is
-//! decided once per stream; every styled string resets at its end so
-//! nothing bleeds.
+//! ANSI styling for what the native layer writes to the terminal: the
+//! access log on stdout and server log lines on either stream. (The
+//! Ruby-side startup banner has its own twin in Kino::CLI.) Color
+//! capability is decided once per stream; every styled string resets at
+//! its end so nothing bleeds.
 
 use std::sync::OnceLock;
 
 #[derive(Clone, Copy)]
-enum Stream {
+pub enum Stream {
     Stdout,
     Stderr,
 }
 
-fn enabled(stream: Stream) -> bool {
+/// Whether `stream` is a color terminal: a tty, no NO_COLOR, TERM not dumb.
+pub fn enabled(stream: Stream) -> bool {
     use std::io::IsTerminal;
     static STDOUT: OnceLock<bool> = OnceLock::new();
     static STDERR: OnceLock<bool> = OnceLock::new();
@@ -27,55 +28,51 @@ fn enabled(stream: Stream) -> bool {
     }
 }
 
-/// Wrap `text` in an SGR code (e.g. "31" red, "1" bold, "38;5;208"
-/// 256-color), plain when the stream isn't a color terminal.
-fn paint(stream: Stream, code: &str, text: &str) -> String {
-    if enabled(stream) {
+/// Wrap `text` in an SGR code ("1" bold, "91" bright red, "1;32" bold
+/// green) when `color`, resetting at the end; plain otherwise.
+pub fn sgr(code: &str, text: &str, color: bool) -> String {
+    if color {
         format!("\x1b[{code}m{text}\x1b[0m")
     } else {
         text.to_string()
     }
 }
 
-/// Errors on stderr are bright red (91): the base red slot (31) is
-/// remapped to odd hues by some terminal themes; 91 stays red.
-pub fn red(text: &str) -> String {
-    paint(Stream::Stderr, "91", text)
-}
+/// Dark gray: timestamps and the timing breakdown recede behind the record.
+pub const DIM: &str = "90";
+/// Bold bright white: the arrival line, which has no status to color by.
+pub const BOLD_WHITE: &str = "1;97";
+/// Warnings are yellow.
+pub const WARN: &str = "33";
+/// Errors are bright red (91): the base red slot (31) is remapped to odd
+/// hues by some terminal themes; 91 stays red.
+pub const ERROR: &str = "91";
 
-/// The SGR code for a status class (basic 16-color palette only):
-/// 2xx green, 3xx yellow, 4xx maroon (ANSI color 1, plain dark red),
-/// 5xx bright red, anything else uncolored.
-fn status_sgr(status: u16) -> Option<&'static str> {
+/// The SGR code for a status class, bold so the record leads its line
+/// (basic 16-color palette only): 2xx green, 3xx yellow, 4xx maroon
+/// (ANSI color 1, plain dark red), 5xx bright red, anything else uncolored.
+pub fn status_sgr(status: u16) -> Option<&'static str> {
     match status {
-        200..=299 => Some("32"),
-        300..=399 => Some("33"),
-        400..=499 => Some("31"),
-        500..=599 => Some("91"),
+        200..=299 => Some("1;32"),
+        300..=399 => Some("1;33"),
+        400..=499 => Some("1;31"),
+        500..=599 => Some("1;91"),
         _ => None,
     }
 }
 
-/// Access-log lines on stdout, tinted by status class.
-pub fn status_colored(status: u16, line: &str) -> String {
-    match status_sgr(status) {
-        Some(code) => paint(Stream::Stdout, code, line),
-        None => line.to_string(),
-    }
-}
-
 #[cfg(test)]
 mod tests {
-    use super::status_sgr;
+    use super::{sgr, status_sgr};
 
     #[test]
     fn status_classes_map_to_their_colors() {
-        assert_eq!(status_sgr(200), Some("32")); // green
-        assert_eq!(status_sgr(299), Some("32"));
-        assert_eq!(status_sgr(301), Some("33")); // yellow
-        assert_eq!(status_sgr(404), Some("31")); // maroon
-        assert_eq!(status_sgr(500), Some("91")); // bright red
-        assert_eq!(status_sgr(599), Some("91"));
+        assert_eq!(status_sgr(200), Some("1;32")); // green
+        assert_eq!(status_sgr(299), Some("1;32"));
+        assert_eq!(status_sgr(301), Some("1;33")); // yellow
+        assert_eq!(status_sgr(404), Some("1;31")); // maroon
+        assert_eq!(status_sgr(500), Some("1;91")); // bright red
+        assert_eq!(status_sgr(599), Some("1;91"));
     }
 
     #[test]
@@ -84,4 +81,10 @@ mod tests {
         assert_eq!(status_sgr(199), None);
         assert_eq!(status_sgr(600), None);
     }
+
+    #[test]
+    fn sgr_wraps_and_resets_only_when_coloring() {
+        assert_eq!(sgr("1;32", "ok", true), "\x1b[1;32mok\x1b[0m");
+        assert_eq!(sgr("1;32", "ok", false), "ok");
+    }
 }

data/ext/kino/src/tls.rs

@@ -71,7 +71,8 @@ WJ2lRijROyX9v7f8aSQlb6kEwKhI8kG8SbeUc+zbKkzGgRXNaZHY/mAa
     #[test]
     fn missing_file_paths_error_without_panicking() {
         let err = build_acceptor("/nonexistent/cert.pem", "/nonexistent/key.pem")
-            .err().expect("missing files");
+            .err()
+            .expect("missing files");
         assert!(err.contains("cannot read"));
     }
 
@@ -83,14 +84,20 @@ WJ2lRijROyX9v7f8aSQlb6kEwKhI8kG8SbeUc+zbKkzGgRXNaZHY/mAa
 
     #[test]
     fn pem_without_a_key_is_rejected() {
-        let err = build_acceptor(CERT, CERT).err().expect("a cert is not a key");
+        let err = build_acceptor(CERT, CERT)
+            .err()
+            .expect("a cert is not a key");
         assert!(err.contains("no private key found"));
     }
 
     #[test]
     fn mismatched_cert_and_garbage_key_are_rejected() {
-        let err = build_acceptor(CERT, "-----BEGIN PRIVATE KEY-----\ngarbage\n-----END PRIVATE KEY-----")
-            .err().expect("garbage key");
+        let err = build_acceptor(
+            CERT,
+            "-----BEGIN PRIVATE KEY-----\ngarbage\n-----END PRIVATE KEY-----",
+        )
+        .err()
+        .expect("garbage key");
         assert!(!err.is_empty());
     }
 }