kino 0.1.0 → 0.1.2

data/ext/kino/src/server.rs

@@ -51,6 +51,8 @@ pub fn server_start(ruby: &Ruby, config: magnus::RHash) -> Result<(u64, u16), Er
     let queue_depth: usize = cfg(ruby, config, "queue_depth")?;
     let queue_timeout_ms: u64 = cfg(ruby, config, "queue_timeout_ms")?;
     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 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")?;
@@ -104,6 +106,7 @@ pub fn server_start(ruby: &Ruby, config: magnus::RHash) -> Result<(u64, u16), Er
         rejected: std::sync::atomic::AtomicU64::new(0),
         queue_timeout_ms,
         request_timeout_ms,
+        max_body_size,
         timeouts: std::sync::atomic::AtomicU64::new(0),
         https: acceptor.is_some(),
         access_log: log_requests.then(|| crate::logsink::Sink::new(std::io::stdout())),
@@ -120,6 +123,7 @@ pub fn server_start(ruby: &Ruby, config: magnus::RHash) -> Result<(u64, u16), Er
         tokio_listener,
         acceptor,
         server.clone(),
+        max_connections,
         shutdown_rx,
     ));
     *server.runtime.lock() = Some(runtime);
@@ -129,40 +133,73 @@ pub fn server_start(ruby: &Ruby, config: magnus::RHash) -> Result<(u64, u16), Er
     Ok((id, local_port))
 }
 
+/// Slowloris guard for TLS: a client that completes the TCP connect but then
+/// stalls the handshake would otherwise hold a connection slot indefinitely
+/// (the per-request and header-read deadlines only start once hyper is
+/// serving, i.e. after the handshake). A handshake is a few round trips, so
+/// this is generous even for a high-latency client. Fixed, like the header
+/// timeout: not a knob.
+const TLS_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(10);
+
 async fn accept_loop(
     listener: tokio::net::TcpListener,
     acceptor: Option<tokio_rustls::TlsAcceptor>,
     server: Arc<ServerInner>,
+    max_connections: usize,
     mut shutdown_rx: tokio::sync::watch::Receiver<bool>,
 ) {
+    // Bound concurrent connections: unbounded, a flood spawns a task and holds
+    // a socket per connection until file descriptors or memory run out. One
+    // permit per live connection; acquiring BEFORE accept leaves the excess in
+    // the kernel backlog (backpressure) rather than accepting then dropping.
+    let conn_limit = Arc::new(tokio::sync::Semaphore::new(max_connections));
     loop {
-        tokio::select! {
+        let permit = tokio::select! {
             _ = shutdown_rx.changed() => break,
-            accepted = listener.accept() => {
-                let Ok((stream, remote_addr)) = accepted else { continue };
-                // 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 {
-                    match acceptor {
-                        Some(acceptor) => {
-                            // Handshake failures (port scans, plain HTTP to a
-                            // TLS port) just drop the connection.
-                            let Ok(tls) = acceptor.accept(stream).await else { return };
-                            serve_connection(tls, server, remote_addr, local_addr).await;
-                        }
-                        None => serve_connection(stream, server, remote_addr, local_addr).await,
-                    }
-                });
+            permit = conn_limit.clone().acquire_owned() => match permit {
+                Ok(permit) => permit,
+                Err(_) => break, // semaphore closed
+            },
+        };
+        let (stream, remote_addr) = tokio::select! {
+            _ = shutdown_rx.changed() => break,
+            accepted = listener.accept() => match accepted {
+                Ok(pair) => pair,
+                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,
             }
-        }
+        });
     }
 }
 
+/// 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
+/// constant, not a config knob: fine-tuning intake limits is the fronting
+/// proxy's job; the actual hazard was having no default at all.
+const HEADER_READ_TIMEOUT: Duration = Duration::from_secs(15);
+
 async fn serve_connection<I>(
     io: I,
     server: Arc<ServerInner>,
@@ -176,7 +213,13 @@ async fn serve_connection<I>(
     // No auto Date header: it costs a clock read per response (together
     // with timer reads, ~7% of tokio-side cycles in the profile); it's a
     // SHOULD not a MUST, and apps that need it can set it themselves.
+    //
+    // The timer is installed so header_read_timeout actually fires: hyper's
+    // slow-header guard is inert without one. It arms only while the request
+    // head is being read, so it adds no per-response cost on the hot path.
     let _ = hyper::server::conn::http1::Builder::new()
+        .timer(hyper_util::rt::TokioTimer::new())
+        .header_read_timeout(HEADER_READ_TIMEOUT)
         .auto_date_header(false)
         .serve_connection(TokioIo::new(io), service)
         .await;
@@ -198,6 +241,25 @@ fn branded(mut response: HyperResponse) -> HyperResponse {
     response
 }
 
+/// A single valid Content-Length as a byte count. hyper has already rejected
+/// conflicting/duplicate values, so the first is authoritative; anything
+/// unparseable yields None and the streaming cap still applies.
+fn content_length(headers: &http::HeaderMap) -> Option<u64> {
+    headers
+        .get(http::header::CONTENT_LENGTH)?
+        .to_str()
+        .ok()?
+        .trim()
+        .parse()
+        .ok()
+}
+
+/// Idle deadline between request-body frames. A client that stalls mid-body
+/// would otherwise hold a worker slot indefinitely (the worker blocks in
+/// read_body). Generous: a real upload sends steadily and resets this each
+/// frame, so only a silent client trips it. Fixed, like the header timeout.
+const BODY_READ_TIMEOUT: Duration = Duration::from_secs(30);
+
 async fn handle_request(
     server: Arc<ServerInner>,
     remote_addr: SocketAddr,
@@ -221,19 +283,50 @@ async fn handle_request(
         )
     });
 
+    // Body-size guard: an honestly-declared oversize body is refused with a
+    // 413 below, before any worker runs. Chunked or lying clients are caught
+    // by the forwarder, which caps cumulative bytes and flags an overflow so
+    // read_body raises instead of letting the app buffer without bound.
+    let max_body = server.max_body_size;
+    let oversize =
+        max_body > 0 && content_length(&parts.headers).is_some_and(|len| len > max_body as u64);
+
     // Stream the request body through a bounded channel: hyper is polled
     // only as fast as the Ruby side consumes (inbound backpressure), and the
     // forwarder dropping the sender is EOF. Bodyless requests (most GETs)
     // skip the forwarder task entirely: dropping the sender IS the EOF.
     let (body_tx, body_rx) = flume::bounded::<bytes::Bytes>(8);
-    if hyper::body::Body::is_end_stream(&body) {
+    let body_overflow = Arc::new(std::sync::atomic::AtomicBool::new(false));
+    let body_timeout = Arc::new(std::sync::atomic::AtomicBool::new(false));
+    if oversize || hyper::body::Body::is_end_stream(&body) {
         drop(body_tx);
     } else {
+        let overflow = body_overflow.clone();
+        let timed_out = body_timeout.clone();
         tokio::spawn(async move {
             let mut body = body;
-            while let Some(frame) = body.frame().await {
-                let Ok(frame) = frame else { break };
+            let mut total: u64 = 0;
+            loop {
+                // Idle deadline between frames: a client that stalls mid-body
+                // would otherwise pin a worker blocked in read_body. Only the
+                // client's silence trips this; a slow APP blocks the forwarder
+                // in send_async below instead, which is not timed.
+                let frame = match tokio::time::timeout(BODY_READ_TIMEOUT, body.frame()).await {
+                    Ok(Some(Ok(frame))) => frame,
+                    Ok(Some(Err(_))) | Ok(None) => break, // body error or clean EOF
+                    Err(_) => {
+                        timed_out.store(true, Ordering::Relaxed);
+                        break;
+                    }
+                };
                 if let Ok(data) = frame.into_data() {
+                    total += data.len() as u64;
+                    if max_body > 0 && total > max_body as u64 {
+                        // Past the cap: flag it and stop pulling. Dropping the
+                        // sender unblocks read_body, which then raises.
+                        overflow.store(true, Ordering::Relaxed);
+                        break;
+                    }
                     if body_tx.send_async(data).await.is_err() {
                         break; // request handle dropped; stop pulling
                     }
@@ -253,6 +346,8 @@ async fn handle_request(
         local_addr,
         https: server.https,
         body_rx,
+        body_overflow,
+        body_timeout,
         leftover: None,
         slot: None,
         responder,
@@ -273,6 +368,9 @@ async fn handle_request(
 
     // Single exit point so the access log sees every outcome, 503s included.
     let response: HyperResponse = 'resp: {
+        if oversize {
+            break 'resp plain_response(413, "Payload Too Large\n");
+        }
         if server.lanes {
             if !dispatch_to_lane(&server, ctx).await {
                 break 'resp unavailable(&server);

data/lib/kino/configuration.rb

@@ -12,11 +12,13 @@ module Kino
       bind: "127.0.0.1",
       port: 0,
       workers: nil, # resolved to Etc.nprocessors in #to_h
-      threads: 3,
+      threads: nil, # resolved per mode in Server: 1 in :ractor, 3 in :threaded
       mode: :auto,
       queue_depth: 1024,
-      queue_timeout: 1.0,
+      queue_timeout: 5.0,
       request_timeout: nil,
+      max_connections: nil, # nil = derive from the open-file limit
+      max_body_size: 50 * 1024 * 1024, # 50 MB; nil/0 = unlimited
       batch: 1,
       lanes: false,
       log_requests: false,
@@ -144,7 +146,8 @@ module Kino
       # Worker count (ractors in :ractor mode); defaults to CPU cores.
       def workers(count) = @config.set(:workers, Integer(count))
 
-      # Threads per worker (I/O concurrency inside one ractor).
+      # Threads per worker (I/O concurrency inside one ractor); default is
+      # mode-dependent: 1 in :ractor mode, 3 in :threaded.
       def threads(count) = @config.set(:threads, Integer(count))
 
       # Dispatch mode: :auto, :ractor, or :threaded.
@@ -159,6 +162,14 @@ module Kino
       # Seconds the app gets before the client receives a 504; nil = off.
       def request_timeout(seconds) = @config.set(:request_timeout, seconds && Float(seconds))
 
+      # Max connections served at once; beyond it, new connections wait in
+      # the kernel backlog. Defaults to most of the open-file limit.
+      def max_connections(count) = @config.set(:max_connections, Integer(count))
+
+      # Max request-body bytes before a 413; nil disables (delegate to a
+      # fronting proxy). Default 50 MB.
+      def max_body_size(bytes) = @config.set(:max_body_size, bytes && Integer(bytes))
+
       # Requests a worker may grab per queue visit (default 1).
       def batch(count) = @config.set(:batch, Integer(count))
 

data/lib/kino/server.rb

@@ -41,11 +41,17 @@ module Kino
       @bind = settings[:bind]
       @requested_port = settings[:port]
       @workers = Integer(settings[:workers])
-      @threads = Integer(settings[:threads])
       @mode = resolve_mode(settings[:mode])
+      # Default threads per mode: 1 in :ractor (threads inside a ractor
+      # share its lock; a measured +17% on fast handlers; raise `workers`
+      # for I/O concurrency instead), 3 in :threaded (threads ARE the
+      # concurrency there).
+      @threads = Integer(settings[:threads] || ((@mode == :ractor) ? 1 : 3))
       @queue_depth = Integer(settings[:queue_depth])
       @queue_timeout_ms = (Float(settings[:queue_timeout]) * 1000).round
       @request_timeout_ms = settings[:request_timeout] ? (Float(settings[:request_timeout]) * 1000).round : 0
+      @max_connections = settings[:max_connections] ? Integer(settings[:max_connections]) : default_max_connections
+      @max_body_size = Integer(settings[:max_body_size] || 0)
       @batch = [Integer(settings[:batch]), 1].max
       @lanes = !!settings[:lanes]
       @log_requests = !!settings[:log_requests]
@@ -70,6 +76,8 @@ module Kino
         bind: @bind, port: @requested_port,
         queue_depth: @queue_depth, queue_timeout_ms: @queue_timeout_ms,
         request_timeout_ms: @request_timeout_ms,
+        max_connections: @max_connections,
+        max_body_size: @max_body_size,
         tokio_threads: @tokio_threads,
         tls_cert: @tls&.fetch(:cert), tls_key: @tls&.fetch(:key),
         lanes: @lanes, log_requests: @log_requests
@@ -210,6 +218,18 @@ module Kino
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
+    # Default connection cap: most of the process open-file limit. A
+    # connection flood's failure mode is descriptor exhaustion, and in
+    # :ractor/:threaded mode the app's own sockets and files share this
+    # process's table, so leave headroom. Scales with `ulimit -n`; raise the
+    # OS limit (or set max_connections) to allow more.
+    def default_max_connections
+      soft, = Process.getrlimit(Process::RLIMIT_NOFILE)
+      return 65_536 if soft == Process::RLIM_INFINITY
+
+      [soft * 8 / 10, 64].max
+    end
+
     def join_workers(deadline)
       if @supervisor
         @supervisor.shutdown([deadline - monotonic_now, 0].max)

data/lib/kino/templates/kino.rb.tt

@@ -1,141 +1,121 @@
-# frozen_string_literal: true
-
 # Kino configuration.
 # Generated by `kino --init`.
 #
-# Every setting below is shown with its default value, commented out:
-# the file is a valid no-op until you uncomment something. Precedence:
-# explicit Server.new kwargs / CLI flags > this file > built-in defaults.
+# Every setting is shown with its default value and commented out, so
+# this file works as-is: uncomment what you want to change.
+# Command-line flags beat this file; this file beats built-in defaults.
 
 ## Network
 
-# Address to listen on. Use "0.0.0.0" to accept non-local connections.
+# Address to listen on. Use "0.0.0.0" to accept connections from other
+# machines.
 # bind "127.0.0.1"
 
-# Port to listen on. 0 picks an ephemeral port (readable via server.port).
-# The `kino` CLI defaults this to 9292 when nothing else sets it.
+# Port to listen on.
 # port 9292
 
-# TLS termination (rustls, in Rust; never blocks a Ruby thread).
-# Values are file paths or inline PEM strings. ALPN is http/1.1.
+# Serve HTTPS. Point these at your certificate and key files (inline
+# PEM strings also work).
 # tls cert: "config/certs/server.pem", key: "config/certs/server.key"
 
 ## Topology
 
-# Puma-style two-level topology: `workers` × `threads`.
-#
-# In :ractor mode, `workers` is the number of worker Ractors: true
-# multi-core parallelism for Ruby CPU work, one per core is a good start.
-# In :threaded mode the same total (workers × threads) runs as plain
-# Threads on the main ractor.
-
-# Defaults to the number of CPU cores (Etc.nprocessors).
+# How many workers to run. Each worker handles requests independently;
+# in :ractor mode every worker runs Ruby in parallel on its own core.
+# Default: one per CPU core.
 # workers 8
 
-# Threads per worker. Threads inside one ractor share its lock, so they
-# only add concurrency where handlers block on I/O (database calls, HTTP).
-# CPU-bound apps gain nothing past 1 (and pay a lock-handoff tax: threads 1
-# measured +17% on fast handlers). I/O-heavy apps want more SLOTS overall -
-# in :ractor mode prefer raising `workers` over `threads` (slots are cheap,
-# no fork memory): 32 workers x 1 thread beat 8x3 by +35% on waits.
-# threads 3
+# Threads inside each worker. More threads help when your app spends
+# time waiting on databases or other services; they do not make Ruby
+# code run faster. Left unset, Kino picks a sensible default for the
+# mode. If your app waits a lot in :ractor mode, prefer raising
+# `workers` instead.
+# threads 1
 
 ## Dispatch mode
 #
-# :auto:     :ractor when the app is Ractor-shareable, else :threaded
-#             (with a warning). Note: a Class used as a Rack app always
-#             counts as "shareable" even if calling it touches unshareable
-#             state; force :threaded for those.
-# :ractor:   require a Ractor-shareable app; raises
-#             Kino::UnshareableAppError otherwise. The app must capture
-#             nothing mutable: frozen middleware, Ractor.shareable_proc
-#             endpoints.
-# :threaded: run ANY Rack app (Rails included) on a classic thread pool.
+# :auto     - picks :ractor when your app supports it, else :threaded.
+# :ractor   - runs Ruby in parallel on all cores. Your app must be
+#             Ractor-shareable; check yours with `kino --check`.
+# :threaded - works with any Rack app, including Rails.
 # mode :auto
 
 ## Backpressure
 
-# Bounded request queue between the Rust front-end and Ruby workers.
-# When it stays full past queue_timeout, clients get an immediate 503
-# instead of waiting forever.
+# How many requests may wait in line. When the line stays full, new
+# requests are turned away with a 503 instead of waiting forever.
 # queue_depth 1024
 
-# Seconds a request may wait for queue space before the 503.
-# queue_timeout 1.0
+# How long (in seconds) a request may wait for a free spot before
+# getting the 503.
+# queue_timeout 5.0
 
-# Seconds the app gets to produce a response before the client receives a
-# 504 instead. Off by default (nil = wait forever). The handler is NOT
-# killed - its late response is dropped and its slot stays busy until it
-# returns, so size this above your slowest legitimate endpoint.
+# Give up on a response after this many seconds: the client gets a 504
+# while your app finishes in the background. Off unless set. Set it
+# above your slowest legitimate endpoint.
 # request_timeout 30
 
-# Requests a worker may grab per queue visit. Values above 1 squeeze more
-# throughput out of uniformly fast handlers, but add head-of-line blocking
-# behind slow ones and stretch the effective queue depth - leave at 1
-# unless your handlers are all sub-millisecond.
+# Most connections to serve at once. Past this, new connections wait in
+# the kernel backlog instead of piling up until the server runs out of
+# file descriptors. Defaults to most of the open-file limit (ulimit -n),
+# so it scales with the OS limit and only bites under a flood.
+# max_connections 8192
+
+# Reject request bodies larger than this many bytes with a 413, so an
+# oversized or endless upload can't drive your app to run out of memory.
+# Set to nil to disable and let a fronting proxy handle it. Default: 50 MB.
+# max_body_size 50 * 1024 * 1024
+
+# How many requests a worker grabs from the line at once. Leave at 1
+# unless all your endpoints are uniformly fast.
 # batch 1
 
-# EXPERIMENTAL lane dispatch: per-worker queues with awake-preferring
-# assignment and work stealing. Cuts per-request wakeups for uniformly
-# fast handlers; semantics under overload are slightly different (per-lane
-# caps with brief dispatcher retries instead of one global queue).
+# Experimental dispatcher that gives each worker its own line. Faster
+# for quick handlers; behavior under heavy overload differs slightly.
 # lanes false
 
-# Native access log: one line per request to stdout, written by a
-# Rust-side flusher thread - request threads never block on the log.
-#
-# On color terminals lines are tinted by status class (2xx green,
-# 3xx yellow, 4xx maroon, 5xx bright red). This is the SERVER's view - it
-# includes the 503 rejections your app never sees - and it interleaves
-# cleanly with your app's own log (e.g. Rails') on stdout. See also
-# Kino::Logger for routing the app log through the same async sink.
-#
-# Try enabling it in the development environment.
+# Print one line per request to stdout, colored by status on a
+# terminal. This is the server's view: it includes requests your app
+# never saw, such as 503s. Recommended in development.
 # log_requests false
 
 ## Lifecycle
 
-# Graceful-shutdown drain deadline in seconds: in-flight requests get this
-# long to finish; past it, their clients receive 500s and workers are
-# reaped. A second INT/TERM force-exits immediately.
+# On shutdown, give in-flight requests this many seconds to finish.
+# A second Ctrl-C (or signal) force-exits immediately.
 # shutdown_timeout 30
 
-# Write the master PID here on start; removed on graceful shutdown.
+# Write the server's process id to this file on start.
 # pidfile "tmp/pids/kino.pid"
 
 ## Runtime
 
-# Threads for the tokio (Rust I/O) runtime. Default (nil) lets tokio use
-# one per core: right for I/O-heavy apps. For CPU-heavy apps this is a
-# real lever: `tokio_threads 1` + `threads 1` measured +26% on a pure-CPU
-# benchmark (every spare thread is Ruby work you didn't run).
+# Threads for the Rust I/O engine. The default suits most apps; for
+# heavily CPU-bound apps, try 1 to leave more cores for Ruby.
 # tokio_threads 4
 
 ## App
 
-# Rackup file the `kino` CLI loads (positional CLI argument wins).
+# Rackup file to load (a command-line argument wins).
 # rackup "config.ru"
 
-# Sets RACK_ENV (unless already set) before the app is loaded by the CLI.
+# Sets RACK_ENV before the app is loaded, unless already set.
 # environment "production"
 
 ## Rails
 #
-# Rails runs on Kino TODAY in :threaded mode; uncomment for a Rails app:
+# Rails runs on Kino today in :threaded mode:
 #
 #   mode :threaded
 #   environment "production"
 #   threads 5                 # match your database pool size
 #
-# Recommended Rails-side settings to pair with Kino:
-#   - config.eager_load = true and no code reloading (production defaults):
-#     Kino's workers serve concurrently; lazy class loading under
-#     concurrency is slow and, in ractor mode, unsafe.
-#   - Database pool >= workers × threads (config/database.yml `pool:`).
-#   - Rails.logger goes to stdout/stderr or a thread-safe device.
+# Rails-side tips:
+#   - Run with eager loading and no code reloading (the production
+#     defaults).
+#   - Set the database pool to at least workers x threads.
+#   - Send logs to stdout or another thread-safe destination.
 #
-# Rails main is being ractorized, but
-# Rails.application still captures unshareable state at boot; known
-# blockers are documented in Kino's README. Track rails/rails main; when
-# Ractor.make_shareable(Rails.application) succeeds, `mode :ractor` here
-# is all you'll need to change.
+# Ractor mode cannot run Rails yet; the blockers are upstream in Rails.
+# Once `Ractor.make_shareable(Rails.application)` works, switching to
+# `mode :ractor` here is all you will need.

data/lib/kino/version.rb

@@ -2,5 +2,5 @@
 
 module Kino
   # The gem version (single source of truth; ext/kino/Cargo.toml syncs).
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/sig/kino.rbs

@@ -92,6 +92,8 @@ module Kino
       def queue_depth: (int depth) -> untyped
       def queue_timeout: (Numeric seconds) -> untyped
       def request_timeout: (Numeric? seconds) -> untyped
+      def max_connections: (int count) -> untyped
+      def max_body_size: (int? bytes) -> untyped
       def batch: (int count) -> untyped
       def lanes: (boolish enabled) -> untyped
       def log_requests: (boolish enabled) -> untyped

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kino
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Yaroslav Markin