kino 0.3.0 → 0.5.0

data/lib/kino/cli.rb

@@ -100,14 +100,14 @@ module Kino
       end.join
     end
 
-    # One-line stats dump (the SIGUSR1 handler's output). Excludes
+    # One-line stats dump (what the SIGUSR1 handler logs). Excludes
     # worker_status: it's an array with one entry per execution slot, and
     # printing it inline would break the one-line contract (see /stats for
     # per-worker detail).
     # @param stats [Hash{Symbol => Object}] see {Kino::Server#stats}
     # @return [String]
     def stats_line(stats)
-      dim("Kino stats: #{stats.except(:worker_status).map { |k, v| "#{k}=#{v.inspect}" }.join(" ")}")
+      "stats #{stats.except(:worker_status).map { |k, v| "#{k}=#{v.inspect}" }.join(" ")}"
     end
 
     # The two banner halves around Server#start: credits before, the ready
@@ -119,15 +119,27 @@ module Kino
       puts dim("\nKino #{VERSION} presents:")
     end
 
+    # The ready block: what this process is (Ruby build with its JIT and
+    # parser flags, environment, topology, pid) and where it listens.
     # @param server [Kino::Server] a started server
     # @return [void]
     def action!(server)
-      puts dim("- mode:      #{server.mode}")
-      puts dim("- listening: http#{"s" if server.tls?}://#{server.bind}:#{server.port}")
+      stats = server.stats
+      puts dim("- ruby:      #{RUBY_DESCRIPTION}")
+      puts dim("- env:       #{ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"}")
+      puts dim("- mode:      #{server.mode}, #{count(stats[:workers], "worker")} × #{count(stats[:threads], "thread")}")
+      puts dim("- pid:       #{Process.pid}")
+      puts dim("- listening: #{server.url}")
+      puts dim("- control:   #{server.control_url}") if server.control_url
       puts dim("- Ctrl-C to drain and stop")
       puts "\n#{bold("Action!")}\n\n"
     end
 
+    # "1 worker", "8 workers".
+    def count(number, noun)
+      "#{number} #{noun}#{"s" unless number == 1}"
+    end
+
     # Roll credits when the process ends: normal exit or crash (at_exit
     # also runs after an uncaught exception; only a force-exit skips it).
     # @return [void]
@@ -200,7 +212,7 @@ module Kino
     def option_parser(options)
       OptionParser.new do |opts|
         opts.banner = "Usage: kino [options] [rackup file (default: config.ru)]"
-        opts.on("-C", "--config FILE", "Config file (default: kino.rb if present)") { |v| options[:config_file] = v }
+        opts.on("-C", "--config FILE", "Config file (default: kino.rb, then config/kino.rb)") { |v| options[:config_file] = v }
         opts.on("--init [PATH]", "Write a commented sample config (default: kino.rb) and exit") do |v|
           options[:init_path] = v || "kino.rb"
         end
@@ -236,14 +248,13 @@ module Kino
       require "kino"
       require "rack"
 
-      config_file = options[:config_file]
-      config_file ||= ("kino.rb" if File.exist?("kino.rb"))
+      config_file = options[:config_file] || Configuration.default_path
 
       config = Configuration.new
       config.load_file(config_file) if config_file
       config.merge!(options[:overrides])
       # Default port 9292 when neither the file nor a flag chose one.
-      config.set(:port, 9292) unless config.set?(:port)
+      config.set(:port, Configuration::DEFAULT_SERVING_PORT) unless config.set?(:port)
       config
     end
 
@@ -252,6 +263,6 @@ module Kino
     end
 
     private_class_method :print_help, :option_parser, :write_sample,
-      :resolve_config, :serve
+      :resolve_config, :serve, :count
   end
 end

data/lib/kino/configuration.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "etc"
-
 module Kino
   # Server settings with Puma-style precedence:
   #   explicit Server.new kwargs > config file DSL > defaults.
@@ -11,7 +9,7 @@ module Kino
     DEFAULTS = {
       bind: "127.0.0.1",
       port: 0,
-      workers: nil, # resolved to Etc.nprocessors in #to_h
+      workers: nil, # resolved to Kino.available_parallelism in #to_h
       threads: nil, # resolved per mode in Server: 1 in :ractor, 3 in :threaded
       mode: :auto,
       queue_depth: 1024,
@@ -28,6 +26,8 @@ module Kino
       after_request_complete: nil,
       on_worker_exit: nil,
       shutdown_timeout: 30,
+      io_shards: false,
+      io_threads: nil,
       tokio_threads: nil,
       tls: nil,
       environment: nil,
@@ -45,6 +45,21 @@ module Kino
     # Source template for {.sample}.
     SAMPLE_TEMPLATE = File.expand_path("templates/kino.rb.tt", __dir__)
 
+    # Where the `kino` CLI and the Rack handler look for a config file when
+    # none is named: the project root first, then the Rails-style config/.
+    DEFAULT_PATHS = %w[kino.rb config/kino.rb].freeze
+
+    # The port the CLI and the Rack handler serve on when neither a flag
+    # nor the file chose one (Server.new itself defaults to an ephemeral
+    # port, for embedding).
+    DEFAULT_SERVING_PORT = 9292
+
+    # The first of {DEFAULT_PATHS} that exists in the working directory.
+    # @return [String, nil]
+    def self.default_path
+      DEFAULT_PATHS.find { |path| File.exist?(path) }
+    end
+
     # The fully-commented sample config (see `kino --init`).
     # @return [String]
     def self.sample
@@ -113,7 +128,7 @@ module Kino
     # @return [Hash{Symbol => Object}] every setting, defaults filled in
     def to_h
       SETTINGS.to_h { |key| [key, self[key]] }.tap do |h|
-        h[:workers] ||= Etc.nprocessors
+        h[:workers] ||= Kino.available_parallelism
       end
     end
 
@@ -135,6 +150,8 @@ module Kino
     #   queue_depth 2048
     #   queue_timeout 0.5
     #   shutdown_timeout 15
+    #   io_shards true
+    #   io_threads 6
     #   tokio_threads 4
     #   tls cert: "cert.pem", key: "key.pem"
     #
@@ -146,7 +163,9 @@ module Kino
         @config = config
       end
 
-      # Address to listen on ("0.0.0.0" accepts non-local connections).
+      # Address to listen on: a host ("0.0.0.0" accepts non-local
+      # connections), or "unix:///path/to.sock" for a unix domain socket
+      # (then `port` is unused).
       def bind(host) = @config.set(:bind, host)
 
       # Port to listen on; 0 picks an ephemeral port.
@@ -214,6 +233,12 @@ module Kino
       # Graceful-shutdown drain deadline in seconds.
       def shutdown_timeout(seconds) = @config.set(:shutdown_timeout, seconds)
 
+      # Run native HTTP I/O on current-thread shards instead of Tokio's shared pool.
+      def io_shards(enabled = true) = @config.set(:io_shards, !!enabled)
+
+      # Native HTTP I/O shard count; default with io_shards: half available CPUs.
+      def io_threads(count) = @config.set(:io_threads, Integer(count))
+
       # Threads for the tokio (Rust I/O) runtime; default: one per core.
       def tokio_threads(count) = @config.set(:tokio_threads, Integer(count))
 

data/lib/kino/errors_stream.rb

@@ -2,17 +2,18 @@
 
 module Kino
   # @private
-  # rack.errors: stateless writer into the native logger. Frozen singleton,
+  # rack.errors: stateless writer into the server log (one line per
+  # call, labelled like every other line Kino writes). Frozen singleton,
   # which also makes it Ractor-shareable; one instance serves all workers.
   class ErrorsStream
     def puts(message)
-      Native.log_error(message.to_s)
+      Log.error(message.to_s.chomp)
       nil
     end
 
     def write(message)
       message = message.to_s
-      Native.log_error(message)
+      Log.error(message.chomp)
       message.bytesize
     end
 

data/lib/kino/hook_fire.rb

@@ -4,9 +4,8 @@ module Kino
   # @private
   # Fires a lifecycle hook and turns a raise into a logged line instead of
   # letting it escape. Stateless and touches only its arguments plus
-  # Native.log_error (already called from inside worker ractors today), so
-  # it is safe to call from worker context: no main-ractor state is
-  # captured.
+  # Kino::Log (safe inside worker ractors), so it is safe to call from
+  # worker context: no main-ractor state is captured.
   module HookFire
     module_function
 
@@ -16,7 +15,7 @@ module Kino
       begin
         hook.call(*args)
       rescue => e
-        Native.log_error("#{name} hook raised #{e.class}: #{e.message}")
+        Log.error("#{name} hook raised #{e.class}: #{e.message}")
       end
     end
   end

data/lib/kino/log.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Kino
+  # Server log lines: the lifecycle notices, crash and respawn reports,
+  # hook failures, the failed-request report, and whatever apps write to
+  # `rack.errors`, all in one shape:
+  #
+  #   kino[4213] worker-3: after_worker_boot hook raised RuntimeError: boom
+  #
+  # The label is syslog's `ident[pid]` tag plus the source that spoke: the
+  # worker ractor and/or thread by name, `main` for neither. On color
+  # terminals the label is dim, yellow, or red by level; the message stays
+  # plain. Notes go to stdout, warnings and errors to stderr.
+  #
+  # Hooks may log through here too (`Kino::Log.info "cache warm"`). Every
+  # method is safe inside a worker ractor: the line is handed to the
+  # native layer, which owns the streams, so no ractor touches `$stdout`
+  # or `$stderr` itself.
+  module Log
+    # Frames shown in a failed-request report before the rest are folded.
+    FRAMES = 12
+
+    # The working directory at boot, stripped from backtrace frames so the
+    # app's own code reads `app/controllers/x.rb:9` rather than an
+    # absolute path (frozen: worker ractors read it).
+    WORKING_DIR = File.join(Dir.pwd, "").freeze
+
+    module_function
+
+    # @param message [#to_s]
+    # @return [void]
+    def info(message)
+      Native.log_line("info", source, message.to_s)
+    end
+
+    # @param message [#to_s]
+    # @return [void]
+    def warn(message)
+      Native.log_line("warn", source, message.to_s)
+    end
+
+    # @param message [#to_s]
+    # @return [void]
+    def error(message)
+      Native.log_line("error", source, message.to_s)
+    end
+
+    # The failed-request report: the request line, the error, and where it
+    # raised in the app, then the backtrace with the app's own frames
+    # first (relative to the working directory) and the rest folded.
+    #
+    #   500 GET /boom · RuntimeError: kaboom (app.rb:12:in 'explode')
+    #       app.rb:12:in 'explode'
+    #       /gems/rack-3.2.7/lib/rack/builder.rb:...
+    #       … 38 more
+    #
+    # @param error [Exception]
+    # @param env [Hash] the Rack env of the failed request
+    # @param status [Integer] the status the client got
+    # @return [void]
+    def exception(error, env, status: 500)
+      frames, depth = trace(error)
+      site = frames.first ? " (#{frames.first})" : ""
+      lines = ["#{status} #{env["REQUEST_METHOD"]} #{env["PATH_INFO"]} · #{error.class}: #{error.message}#{site}"]
+      frames.each { |frame| lines << "    #{frame}" }
+      lines << "    … #{depth - frames.size} more" if depth > frames.size
+      error(lines.join("\n"))
+    end
+
+    # The `kino[<pid>] <source>:` tag a line from here carries.
+    # @return [String]
+    def label
+      "kino[#{Process.pid}] #{source}:"
+    end
+
+    # Who is speaking: the ractor's name, the thread's name, both joined
+    # with a slash, or `main` when neither is named. Kino names its
+    # worker ractors and threads `worker-N`.
+    # @return [String]
+    def source
+      parts = [Ractor.current.name, Thread.current.name].compact
+      parts.empty? ? "main" : parts.join("/")
+    end
+
+    # The backtrace as [frames, depth]: each frame relativized to the
+    # working directory, the app's own frames floated to the front (the
+    # raise site in your code reads first; gem and stdlib frames keep
+    # their order below), capped at FRAMES; depth is the real length.
+    def trace(error)
+      raw = error.backtrace || []
+      app, rest = raw.map { |frame| frame.delete_prefix(WORKING_DIR) }.partition { |frame| app_frame?(frame) }
+      [(app + rest).first(FRAMES), raw.size]
+    end
+
+    # A project-relative path (the working-directory prefix came off, so
+    # it does not start with `/`) that is not a synthetic frame (`(eval)`,
+    # `<internal:...>`). Gem and stdlib frames stay absolute.
+    def app_frame?(frame)
+      !frame.start_with?("/", "<", "(")
+    end
+
+    private_class_method :trace, :app_frame?
+  end
+end

data/lib/kino/quarantine_monitor.rb

@@ -21,7 +21,10 @@ module Kino
 
     def start
       @running = true
-      @thread = Thread.new { run }
+      @thread = Thread.new do
+        Thread.current.name = "quarantine"
+        run
+      end
       self
     end
 
@@ -35,14 +38,14 @@ module Kino
     def run
       tick while @running
     rescue => e
-      Native.log_error("quarantine monitor crashed: #{e.class}: #{e.message}")
+      Log.error("quarantine monitor crashed: #{e.class}: #{e.message}")
     end
 
     def tick
       scan_slots
     rescue => e
       # A bad tick must never kill the monitor.
-      Native.log_error("quarantine tick error: #{e.class}: #{e.message}")
+      Log.error("quarantine tick error: #{e.class}: #{e.message}")
     ensure
       sleep @tick
     end
@@ -53,7 +56,7 @@ module Kino
 
         if @outstanding >= @max
           unless @at_cap_logged
-            Native.log_error("quarantine at cap (#{@max}); serving at reduced capacity")
+            Log.warn("quarantine at cap (#{@max}); serving at reduced capacity")
             @at_cap_logged = true
           end
           next

data/lib/kino/ractor_supervisor.rb

@@ -91,6 +91,7 @@ module Kino
 
     def supervise(index)
       Thread.new do
+        Thread.current.name = "supervisor-#{index}"
         crashes = 0
         loop do
           ractor, worker_ids = spawn_worker(index)
@@ -109,7 +110,7 @@ module Kino
 
             crashes += 1
             Native.record_respawn(@server_id)
-            Native.log_error("worker ractor #{index} crashed (#{cause.class}: #{cause.message}); respawning")
+            Log.error("worker-#{index} crashed (#{cause.class}: #{cause.message}); respawning")
             # Policy (crash recovery): unlimited respawn
             # keeps the server up under rare crashes but turns a
             # crash-on-every-request bug into a busy loop. A circuit breaker
@@ -129,12 +130,16 @@ module Kino
         @worker_slots[worker_index] = worker_ids
         worker_ids.each { |id| @slot_to_worker[id] = worker_index }
       end
-      ractor = Ractor.new(@server_id, worker_ids, @app, @batch, @hooks) do |server_id, ids, app, batch, hooks|
-        ids.map do |id|
+      # Named so log lines from inside say which worker spoke: the ractor
+      # alone for a single thread, `worker-N/thread-M` for more.
+      ractor = Ractor.new(@server_id, worker_ids, @app, @batch, @hooks,
+        name: "worker-#{worker_index}") do |server_id, ids, app, batch, hooks|
+        ids.each_with_index.map do |id, position|
           Thread.new do
             # Crashes surface via Ractor#value in the supervisor; don't also
             # spray the backtrace to stderr from inside the dying ractor.
             Thread.current.report_on_exception = false
+            Thread.current.name = "thread-#{position + 1}" if ids.size > 1
             Kino::Worker.run(server_id, id, app, batch, hooks)
           end
         end.each(&:join)

data/lib/kino/server.rb

@@ -27,6 +27,29 @@ module Kino
       !@tls.nil?
     end
 
+    # @return [Boolean] whether the bind is a unix domain socket
+    #   ("unix:///path/to.sock")
+    def unix?
+      @bind.start_with?("unix://")
+    end
+
+    # Where the server listens, once started: `http://host:port`
+    # (`https` under TLS), or the `unix://` socket path.
+    # @return [String]
+    def url
+      unix? ? @bind : "http#{"s" if tls?}://#{@bind}:#{@port}"
+    end
+
+    # Where the control plane listens, once started, or nil when it is
+    # off: `http://host:port`, or its `unix://` socket path.
+    # @return [String, nil]
+    def control_url
+      return nil unless @control_bind
+      return @control_bind if @control_bind.start_with?("unix://")
+
+      "http://#{@control_bind.rpartition(":").first}:#{@control_port}"
+    end
+
     # Settings precedence: explicit kwargs > config_file DSL > defaults.
     #
     # @param app [#call] a Rack 3 application
@@ -54,7 +77,12 @@ module Kino
       @worker_hooks = WorkerHooks.new(
         on_error: @on_error,
         after_worker_boot: @after_worker_boot,
-        after_request_complete: @after_request_complete
+        after_request_complete: @after_request_complete,
+        # The access log's GC and allocation figures come from the VM's
+        # process-wide counters, so they are measured only where one
+        # request at a time can own them: the GVL serializes :threaded
+        # mode, and a single ractor has nothing to race.
+        access_timing: !!settings[:log_requests] && (@mode == :threaded || @workers == 1)
       )
       # Default threads per mode: 1 in :ractor (threads inside a ractor
       # share its lock; a measured +17% on fast handlers; raise `workers`
@@ -70,8 +98,17 @@ module Kino
       @lanes = !!settings[:lanes]
       @log_requests = !!settings[:log_requests]
       @shutdown_timeout = settings[:shutdown_timeout]
+      @io_shards = !!settings[:io_shards]
+      @io_threads = Integer(settings[:io_threads]) unless settings[:io_threads].nil?
+      if @io_threads && @io_threads < 1
+        raise ArgumentError, "io_threads must be >= 1"
+      end
+      Log.warn("io_threads has no effect unless io_shards is true") if @io_threads && !@io_shards
       @tokio_threads = settings[:tokio_threads]
       @tls = validate_tls(settings[:tls])
+      if @tls && unix?
+        raise ArgumentError, "TLS is not supported on a unix socket bind; terminate TLS at the proxy in front"
+      end
       @pidfile = settings[:pidfile]
       @control_bind = settings[:control_bind]&.to_s
       @control_token = settings[:control_token]&.to_s
@@ -114,6 +151,8 @@ module Kino
           request_timeout_ms: @request_timeout_ms,
           max_connections: @max_connections,
           max_body_size: @max_body_size,
+          io_shards: @io_shards,
+          io_threads: @io_threads,
           tokio_threads: @tokio_threads,
           tls_cert: @tls&.fetch(:cert), tls_key: @tls&.fetch(:key),
           lanes: @lanes, log_requests: @log_requests,
@@ -195,22 +234,34 @@ module Kino
       @supervisor ? @supervisor.join : @worker_threads.each(&:join)
     end
 
-    # Production entry point: start, print the banner, trap INT/TERM for
-    # graceful shutdown (second signal force-exits), block until done.
-    # The `kino` CLI funnels into this too (CLI#serve).
+    # Production entry point: build the server and {#run} it. The `kino`
+    # CLI funnels into this too (CLI#serve).
     #
     # @param app [#call] a Rack 3 application
     # @param opts [Hash] see #initialize
     # @return [Kino::Server] the (stopped) server, after shutdown
     def self.run(app, **opts)
-      server = new(app, **opts)
+      new(app, **opts).run
+    end
+
+    # Serve until shut down: start, print the banner, trap INT/TERM for
+    # graceful shutdown (second signal force-exits), block until done.
+    # The Rack handler calls this on a server it built itself.
+    #
+    # @return [self] after shutdown
+    def run
+      # Startup output must land immediately even when stdout is a pipe or
+      # file (process supervisors, `kino > server.log`, `rails server`
+      # under Docker); block buffering would hold the banner back until
+      # exit.
+      $stdout.sync = true
       CLI.opening_credits
-      server.start
-      CLI.action!(server)
+      start
+      CLI.action!(self)
       CLI.fin_at_exit
-      trap_signals(server)
-      server.wait
-      server
+      self.class.trap_signals(self)
+      wait
+      self
     end
 
     # Signal handling shared by Server.run and the kino CLI: INT/TERM drain
@@ -222,14 +273,14 @@ module Kino
       # kill -USR1 <pid> prints a one-line stats snapshot (find the pid in
       # the pidfile when configured).
       trap("USR1") do
-        Thread.new { $stdout.puts Kino::CLI.stats_line(server.stats) }
+        Thread.new { Log.info(CLI.stats_line(server.stats)) }
       end
       signaled = false
       %w[INT TERM].each do |signal|
         trap(signal) do
           Process.exit!(1) if signaled
           signaled = true
-          $stderr.write("Kino: draining (signal again to force exit)\n")
+          Log.warn("draining (signal again to force exit)")
           # Trap context forbids mutexes; do the real work on a thread.
           Thread.new { server.shutdown }
         end
@@ -270,6 +321,8 @@ module Kino
     def spawn_worker_thread
       worker_id = Native.register_worker(@id)
       Thread.new do
+        # Named so log lines from inside say which worker spoke.
+        Thread.current.name = "worker-#{worker_id}"
         error = nil
         begin
           Worker.run(@id, worker_id, @app, @batch, @worker_hooks)
@@ -442,7 +495,7 @@ module Kino
       if @supervisor
         # Ractors cannot be force-killed; their clients were already freed
         # by abort_all_inflight. The stuck ractor leaks until process exit.
-        Native.log_error("shutdown deadline passed with stuck ractor workers") unless @supervisor.done?
+        Log.error("shutdown deadline passed with stuck ractor workers") unless @supervisor.done?
       else
         threads = @worker_threads_lock.synchronize { @worker_threads.dup }
         threads.each { |thread| thread.kill if thread.alive? }
@@ -474,10 +527,10 @@ module Kino
         :ractor
       when :auto
         if !Ractor.shareable?(@app)
-          warn "Kino: app is not Ractor-shareable; falling back to mode: :threaded"
+          Log.warn("app is not Ractor-shareable; falling back to mode: :threaded")
           :threaded
         elsif (name = unshareable_worker_hook_name)
-          warn "Kino: #{name} hook is not Ractor-shareable; falling back to mode: :threaded"
+          Log.warn("#{name} hook is not Ractor-shareable; falling back to mode: :threaded")
           :threaded
         else
           :ractor

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

@@ -8,7 +8,9 @@
 ## Network
 
 # Address to listen on. Use "0.0.0.0" to accept connections from other
-# machines.
+# machines, or "unix:///run/kino.sock" to listen on a unix domain socket
+# behind a proxy such as nginx (the port below is then unused; a stale
+# socket file is reclaimed, a live one refused).
 # bind "127.0.0.1"
 
 # Port to listen on.
@@ -22,7 +24,8 @@
 
 # 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.
+# Default: the CPUs this process may use (Kino.available_parallelism:
+# the affinity mask and, in a container, the cgroup CPU quota).
 # workers 8
 
 # Threads inside each worker. More threads help when your app spends
@@ -74,9 +77,12 @@
 # for quick handlers; behavior under heavy overload differs slightly.
 # lanes false
 
-# 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 every request to stdout: an arrival line before the app runs and a
+# completion line after it, colored by status on a terminal, with a
+# timing breakdown (time in Ruby with its GC pause and allocations, the
+# server's own overhead, and queue wait). This is the server's view: it
+# includes requests your app never saw, such as 503s. Recommended in
+# development; cheap enough for production.
 # log_requests false
 
 # Called when a worker catches an app or delivery error, after the client
@@ -119,8 +125,14 @@
 
 ## Runtime
 
-# 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.
+# Run native HTTP I/O on current-thread shards instead of Tokio's shared
+# worker pool, reducing scheduler contention on very fast handlers.
+# io_shards true
+
+# I/O shard count. Default with io_shards: half available CPUs.
+# io_threads 6
+
+# Threads for the Tokio multi-thread runtime. Default: one per available CPU.
 # tokio_threads 4
 
 ## Control plane

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.3.0"
+  VERSION = "0.5.0"
 end

data/lib/kino/worker.rb

@@ -70,7 +70,16 @@ module Kino
     def serve(env, app, hooks)
       request = env[KINO_REQUEST]
       env[RACK_INPUT] ||= Input.new(request)
-      status, headers, body = app.call(env)
+      if hooks&.access_timing
+        # The access log's breakdown: the VM's cumulative GC time and
+        # allocation count, differenced around the app call.
+        gc_before = GC.total_time
+        allocated_before = GC.stat(:total_allocated_objects)
+        status, headers, body = app.call(env)
+        request.timing(GC.total_time - gc_before, GC.stat(:total_allocated_objects) - allocated_before)
+      else
+        status, headers, body = app.call(env)
+      end
 
       if body.respond_to?(:to_ary)
         chunks = join_chunks(body.to_ary)
@@ -99,21 +108,12 @@ module Kino
       # delivery errors (they happen after app.call returned, so no
       # middleware can see them); its own failures are logged, not raised,
       # because nothing may escape this block and kill the worker.
-      Native.log_error(error_log_line(e))
+      Log.exception(e, env)
       request.abort
       HookFire.fire(hooks&.on_error, "on_error", e, env)
       NOT_FUSED
     end
 
-    # First frames only: the raise site is at the top, and Rails stacks
-    # run hundreds of middleware frames deep. Hooks get the full exception.
-    BACKTRACE_FRAMES = 12
-
-    def error_log_line(error)
-      ["#{error.class}: #{error.message}",
-        *(error.backtrace || []).first(BACKTRACE_FRAMES)].join("\n  ")
-    end
-
     def deliver_streaming(request, status, headers, body, input)
       request.send_headers(status, headers)
       if body.respond_to?(:call) && !body.respond_to?(:each)
@@ -159,7 +159,6 @@ module Kino
     end
 
     private_class_method :handle_one, :process, :serve, :deliver_streaming,
-      :join_chunks, :error_log_line, :fire_after_worker_boot,
-      :fire_after_request_complete
+      :join_chunks, :fire_after_worker_boot, :fire_after_request_complete
   end
 end

data/lib/kino/worker_hooks.rb

@@ -7,5 +7,7 @@ module Kino
   # several bare procs. Any member may be nil. A Data instance is frozen,
   # so it is Ractor.shareable? exactly when its members are (nil, or a
   # Ractor.shareable_proc), letting it ride the ractor boundary like the app.
-  WorkerHooks = Data.define(:on_error, :after_worker_boot, :after_request_complete)
+  # `access_timing` rides along: whether the worker measures the GC pause
+  # and allocations around each app call for the access log's breakdown.
+  WorkerHooks = Data.define(:on_error, :after_worker_boot, :after_request_complete, :access_timing)
 end