hyperion-rb 1.0.1 → 1.2.0

data/lib/hyperion/prometheus_exporter.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Hyperion
+  # Renders Hyperion.stats as Prometheus text exposition format (v0.0.4).
+  # Mounted by AdminMiddleware on GET /-/metrics; the returned content-type
+  # is `text/plain; version=0.0.4; charset=utf-8`.
+  #
+  # Mapping rules:
+  # - keys listed in KNOWN_METRICS get their canonical name + curated HELP/TYPE
+  # - keys matching `responses_<3-digit>` are grouped under a single
+  #   `hyperion_responses_status_total` family with a `status` label
+  # - any other key is auto-exported as `hyperion_<key>` with a generic HELP
+  #   line, so newly-added counters surface in Prometheus without code changes
+  #   here (the curated-name path is just nicer presentation, not gating)
+  #
+  # Output ordering is deterministic for stable scrape diffs:
+  # - known metrics in KNOWN_METRICS declaration order
+  # - status codes ascending
+  # - other keys alphabetically
+  module PrometheusExporter
+    module_function
+
+    KNOWN_METRICS = {
+      requests: { name: 'hyperion_requests_total',
+                  help: 'Total HTTP requests handled',
+                  type: 'counter' },
+      bytes_read: { name: 'hyperion_bytes_read_total',
+                    help: 'Total bytes read from request sockets',
+                    type: 'counter' },
+      bytes_written: { name: 'hyperion_bytes_written_total',
+                       help: 'Total bytes written to response sockets',
+                       type: 'counter' },
+      rejected_connections: { name: 'hyperion_rejected_connections_total',
+                              help: 'Connections rejected due to backpressure (max_pending)',
+                              type: 'counter' },
+      sendfile_responses: { name: 'hyperion_sendfile_responses_total',
+                            help: 'Responses sent via plain-TCP sendfile(2) zero-copy path',
+                            type: 'counter' },
+      tls_zerobuf_responses: { name: 'hyperion_tls_zerobuf_responses_total',
+                               help: 'Responses sent via TLS IO.copy_stream (avoids userspace String build, but TLS encryption forces copy)',
+                               type: 'counter' }
+    }.freeze
+
+    STATUS_KEY_PATTERN = /\Aresponses_(\d{3})\z/
+
+    STATUS_FAMILY_NAME = 'hyperion_responses_status_total'
+    STATUS_FAMILY_HELP = 'Responses by HTTP status code'
+
+    def render(stats)
+      buf = +''
+      grouped_status = {}
+      other = {}
+      known = {}
+
+      stats.each do |key, value|
+        if (match = key.to_s.match(STATUS_KEY_PATTERN))
+          grouped_status[match[1]] = value
+        elsif KNOWN_METRICS.key?(key)
+          known[key] = value
+        else
+          other[key] = value
+        end
+      end
+
+      # Known metrics first, in declaration order — gives the scrape a stable,
+      # human-friendly preamble regardless of hash insertion order.
+      KNOWN_METRICS.each do |key, meta|
+        next unless known.key?(key)
+
+        append_metric(buf, meta[:name], meta[:help], meta[:type], known[key])
+      end
+
+      unless grouped_status.empty?
+        buf << "# HELP #{STATUS_FAMILY_NAME} #{STATUS_FAMILY_HELP}\n"
+        buf << "# TYPE #{STATUS_FAMILY_NAME} counter\n"
+        grouped_status.sort.each do |status, value|
+          buf << %(#{STATUS_FAMILY_NAME}{status="#{status}"} #{value}\n)
+        end
+      end
+
+      other.sort_by { |k, _| k.to_s }.each do |key, value|
+        name = "hyperion_#{key}"
+        append_metric(buf, name, 'Hyperion internal counter (auto-exported)', 'counter', value)
+      end
+
+      buf
+    end
+
+    def append_metric(buf, name, help, type, value)
+      buf << "# HELP #{name} #{help}\n"
+      buf << "# TYPE #{name} #{type}\n"
+      buf << "#{name} #{value}\n"
+    end
+    private_class_method :append_metric
+  end
+end

data/lib/hyperion/response_writer.rb

@@ -36,6 +36,21 @@ module Hyperion
     CRLF_HEADER_VALUE = /[\r\n]/
 
     def write(io, status, headers, body, keep_alive: false)
+      # Zero-copy fast path: bodies that point at an on-disk file (Rack::Files,
+      # asset servers, signed-download responders) get streamed via
+      # IO.copy_stream which delegates to sendfile(2) on Linux for plain TCP
+      # sockets — bytes go from the file's page cache straight to the socket
+      # buffer with no userspace allocation. For TLS sockets we still avoid the
+      # multi-MB String build, but encryption forces a userspace round-trip so
+      # we count that path separately.
+      return write_sendfile(io, status, headers, body, keep_alive: keep_alive) if body.respond_to?(:to_path)
+
+      write_buffered(io, status, headers, body, keep_alive: keep_alive)
+    end
+
+    private
+
+    def write_buffered(io, status, headers, body, keep_alive:)
       # Phase 1 buffers the full body so Content-Length is exact.
       # Phase 2 introduces chunked transfer-encoding for streaming bodies;
       # Phase 5 batches via IO::Buffer to avoid this intermediate String.
@@ -43,7 +58,7 @@ module Hyperion
       body.each { |chunk| buffered << chunk }
 
       reason = REASONS[status] || 'Unknown'
-      date_str = Time.now.httpdate
+      date_str = cached_date
 
       head = build_head(status, reason, headers, buffered.bytesize, keep_alive, date_str)
 
@@ -51,19 +66,68 @@ module Hyperion
       # SINGLE io.write call. Each syscall round-trip is ~1 usec on macOS
       # kqueue; before this change we issued (1 status) + (N headers) + (1 blank)
       # + (1 body) = 8+ syscalls per response. Now: 1 syscall.
-      if buffered.empty?
-        io.write(head)
-      else
-        # Concatenate into the head buffer (which is already a fresh +'' from
-        # the C builder or the Ruby fallback) so we still emit a single write.
-        head << buffered
-        io.write(head)
-      end
+      bytes_out = if buffered.empty?
+                    io.write(head)
+                    head.bytesize
+                  else
+                    # Concatenate into the head buffer (which is already a fresh +''
+                    # from the C builder or the Ruby fallback) so we still emit a
+                    # single write.
+                    head << buffered
+                    io.write(head)
+                    head.bytesize
+                  end
+      Hyperion.metrics.increment(:bytes_written, bytes_out)
     ensure
       body.close if body.respond_to?(:close)
     end
 
-    private
+    def write_sendfile(io, status, headers, body, keep_alive:)
+      path = body.to_path
+      file = File.open(path, 'rb')
+      file_size = file.size
+
+      # If the app explicitly set content-length, respect it; otherwise use the
+      # real file size. Rack::Files does not pre-set content-length, so the
+      # common case is the File.size branch.
+      content_length = explicit_content_length(headers) || file_size
+
+      reason = REASONS[status] || 'Unknown'
+      date_str = cached_date
+      head = build_head(status, reason, headers, content_length, keep_alive, date_str)
+
+      io.write(head)
+      # IO.copy_stream copies up to file_size bytes from the file to the socket.
+      # On Linux + plain TCPSocket this triggers sendfile(2) — kernel-level
+      # zero-copy. On TLS sockets and non-Linux platforms it falls back to
+      # internal read+write loops, but we still avoid building a String the
+      # size of the file in Ruby.
+      copied = IO.copy_stream(file, io, file_size)
+
+      record_zero_copy_metric(io)
+      Hyperion.metrics.increment(:bytes_written, head.bytesize + copied)
+    ensure
+      file&.close
+      body.close if body.respond_to?(:close)
+    end
+
+    def explicit_content_length(headers)
+      headers.each do |k, v|
+        return v.to_i if k.to_s.casecmp('content-length').zero?
+      end
+      nil
+    end
+
+    # Plain TCPSocket → real sendfile(2). TLS-wrapped sockets cannot use
+    # sendfile (kernel can't encrypt) but still avoid the per-response String
+    # allocation, so we track them under a separate counter.
+    def record_zero_copy_metric(io)
+      if defined?(::OpenSSL::SSL::SSLSocket) && io.is_a?(::OpenSSL::SSL::SSLSocket)
+        Hyperion.metrics.increment(:tls_zerobuf_responses)
+      else
+        Hyperion.metrics.increment(:sendfile_responses)
+      end
+    end
 
     # rc17: prefer the C extension when available — eliminates the per-response
     # status-line interpolation, normalized hash, and per-header String#<<
@@ -76,6 +140,19 @@ module Hyperion
       end
     end
 
+    # Cached HTTP `Date:` header at second resolution. `Time.now.httpdate`
+    # allocates several strings; at high r/s the cache reuses one String per
+    # second per thread instead of allocating per response.
+    def cached_date
+      now_s = Process.clock_gettime(Process::CLOCK_REALTIME, :second)
+      cache = (Thread.current[:__hyperion_date_cache__] ||= [-1, ''])
+      return cache[1] if cache[0] == now_s
+
+      cache[0] = now_s
+      cache[1] = Time.now.httpdate
+      cache[1]
+    end
+
     def build_head_ruby(status, reason, headers, body_size, keep_alive, date_str)
       normalized = {}
       headers.each { |k, v| normalized[k.to_s.downcase] = v }

data/lib/hyperion/server.rb

@@ -20,18 +20,40 @@ module Hyperion
     DEFAULT_READ_TIMEOUT_SECONDS = 30
     DEFAULT_THREAD_COUNT         = 5
 
+    # Pre-built minimal 503 response for the backpressure path. We bypass
+    # ResponseWriter / Rack entirely — no env build, no app dispatch, no
+    # access-log line. The bytes are frozen and reused across every
+    # rejection so the overload path stays allocation-free. Body is JSON
+    # so JSON-only API consumers don't have to special-case the format.
+    REJECT_503 = lambda {
+      body = +%({"error":"server_busy","retry_after_seconds":1}\n)
+      body.force_encoding(Encoding::ASCII_8BIT)
+      head = +"HTTP/1.1 503 Service Unavailable\r\n" \
+              "content-type: application/json\r\n" \
+              "content-length: #{body.bytesize}\r\n" \
+              "retry-after: 1\r\n" \
+              "connection: close\r\n" \
+              "\r\n"
+      head.force_encoding(Encoding::ASCII_8BIT)
+      (head + body).freeze
+    }.call
+
     attr_reader :host, :port
 
     def initialize(app:, host: '127.0.0.1', port: 9292, read_timeout: DEFAULT_READ_TIMEOUT_SECONDS,
-                   tls: nil, thread_count: DEFAULT_THREAD_COUNT)
-      @host         = host
-      @port         = port
-      @app          = app
-      @read_timeout = read_timeout
-      @tls          = tls
-      @thread_count = thread_count
-      @thread_pool  = nil
-      @stopped      = false
+                   tls: nil, thread_count: DEFAULT_THREAD_COUNT, max_pending: nil,
+                   max_request_read_seconds: 60, h2_settings: nil)
+      @host                     = host
+      @port                     = port
+      @app                      = app
+      @read_timeout             = read_timeout
+      @tls                      = tls
+      @thread_count             = thread_count
+      @max_pending              = max_pending
+      @max_request_read_seconds = max_request_read_seconds
+      @h2_settings              = h2_settings
+      @thread_pool              = nil
+      @stopped                  = false
     end
 
     def listen
@@ -83,26 +105,19 @@ module Hyperion
 
     def start
       listen unless @server
-      @thread_pool = ThreadPool.new(size: @thread_count) if @thread_count.positive?
+      @thread_pool = ThreadPool.new(size: @thread_count, max_pending: @max_pending) if @thread_count.positive?
 
-      Async do |task|
-        until @stopped
-          socket = accept_or_nil
-          next unless socket
-
-          apply_timeout(socket)
-          # Plain HTTP/1.1 with a pool: submit straight to the worker — no
-          # fiber wrap needed (submit_connection returns immediately and the
-          # worker thread owns the connection for its lifetime).
-          # TLS still goes through a fiber: ALPN negotiation determines h2
-          # vs http/1.1, and h2 needs the fiber because each stream is its
-          # own fiber inside Http2Handler.
-          if @thread_pool && !@tls
-            @thread_pool.submit_connection(socket, @app)
-          else
-            task.async { dispatch(socket) }
-          end
-        end
+      if @tls
+        # TLS path: ALPN may pick `h2`, and h2 spawns one fiber per stream
+        # inside Http2Handler. Keep the Async wrapper so the scheduler is
+        # available for those fibers and for handshake yields.
+        start_async_loop
+      else
+        # Plain HTTP/1.1: the worker thread owns each connection for its
+        # lifetime, so the Async wrapper adds zero value (no fibers ever
+        # run on this loop's task). Skip it — pure IO.select + accept_nonblock
+        # shaves measurable overhead off the accept hot path.
+        start_raw_loop
       end
     ensure
       @thread_pool&.shutdown
@@ -117,20 +132,79 @@ module Hyperion
 
     private
 
+    # Plain HTTP/1.1 accept loop — no fiber wrap. Connections go straight to
+    # a worker via the thread pool, or are served inline when no pool is
+    # configured (thread_count: 0). Matches the dispatch contract used by
+    # the TLS path; just skips the irrelevant h2/ALPN branch.
+    def start_raw_loop
+      until @stopped
+        socket = accept_or_nil
+        next unless socket
+
+        apply_timeout(socket)
+        if @thread_pool
+          unless @thread_pool.submit_connection(socket, @app,
+                                                max_request_read_seconds: @max_request_read_seconds)
+            reject_connection(socket)
+          end
+        else
+          Connection.new.serve(socket, @app, max_request_read_seconds: @max_request_read_seconds)
+        end
+      end
+    end
+
+    # TLS / h2-capable accept loop. The Async wrapper is required because
+    # h2 streams (inside Http2Handler) and the ALPN handshake yield
+    # cooperatively via the scheduler.
+    def start_async_loop
+      Async do |task|
+        until @stopped
+          socket = accept_or_nil
+          next unless socket
+
+          apply_timeout(socket)
+          task.async { dispatch(socket) }
+        end
+      end
+    end
+
     def dispatch(socket)
       if socket.is_a?(::OpenSSL::SSL::SSLSocket) && socket.alpn_protocol == 'h2'
         # HTTP/2: each stream runs on a fiber inside Http2Handler. The
         # handler still uses the pool's `#call` for app.call hops on each
         # stream (one per stream, not one per connection).
-        Http2Handler.new(app: @app, thread_pool: @thread_pool).serve(socket)
+        Http2Handler.new(app: @app, thread_pool: @thread_pool, h2_settings: @h2_settings).serve(socket)
       elsif @thread_pool
         # HTTP/1.1 (e.g. TLS-wrapped after ALPN picked http/1.1): hand the
         # connection to a worker thread. The fiber that called dispatch
-        # returns immediately.
-        @thread_pool.submit_connection(socket, @app)
+        # returns immediately. On overflow, reject with 503 + close.
+        unless @thread_pool.submit_connection(socket, @app,
+                                              max_request_read_seconds: @max_request_read_seconds)
+          reject_connection(socket)
+        end
       else
         # No pool (thread_count: 0): inline on the calling fiber.
-        Connection.new.serve(socket, @app)
+        Connection.new.serve(socket, @app, max_request_read_seconds: @max_request_read_seconds)
+      end
+    end
+
+    # Backpressure rejection. Emits a pre-built 503 + closes the socket.
+    # No Rack env, no app dispatch, no access-log line — the overload
+    # path must stay cheap so we don't pile rejection cost on top of the
+    # already-saturated workers. Bumps :rejected_connections so operators
+    # can alert on sustained overload.
+    def reject_connection(socket)
+      socket.write(REJECT_503)
+      Hyperion.metrics.increment(:rejected_connections)
+    rescue StandardError
+      # Client may have hung up between accept and our 503 write — that's
+      # the failure mode we're protecting them from anyway, so swallow.
+      nil
+    ensure
+      begin
+        socket.close
+      rescue StandardError
+        nil
       end
     end
 

data/lib/hyperion/thread_pool.rb

@@ -26,11 +26,12 @@ module Hyperion
   class ThreadPool
     SHUTDOWN = :__hyperion_thread_pool_shutdown__
 
-    attr_reader :size
+    attr_reader :size, :max_pending
 
-    def initialize(size:)
-      @size       = size
-      @inbox      = Queue.new # multiplexes both kinds of jobs
+    def initialize(size:, max_pending: nil)
+      @size        = size
+      @max_pending = max_pending
+      @inbox       = Queue.new # multiplexes both kinds of jobs
       # Pre-allocate one reply queue per in-flight slot for the legacy `#call`
       # path. Bounded by `size`: if all workers are busy, all reply queues are
       # checked out, and the next caller blocks on `@reply_pool.pop` until a
@@ -43,8 +44,23 @@ module Hyperion
     # HTTP/1.1 path: hand the whole socket to a worker thread. The worker
     # runs `Connection#serve(socket, app)` directly. No per-request hop.
     # Returns immediately — caller does not wait.
-    def submit_connection(socket, app)
-      @inbox << [:connection, socket, app]
+    #
+    # Returns true on enqueue, false on rejection. When `max_pending` is set
+    # and the inbox already has at least that many entries, the connection
+    # is rejected up to the caller (Server emits a 503 and closes the
+    # socket). Without `max_pending` (default nil) the queue is unbounded
+    # and we always return true — preserves pre-1.2 behaviour.
+    #
+    # The check is inherently racy with worker drain — workers may pop
+    # between our `size` read and the `<<`. Backpressure is statistical,
+    # not strict. Off-by-one over the configured cap during a thundering
+    # accept burst is acceptable; the cost of stricter sync would be a
+    # mutex on every enqueue, which we won't pay on the hot path.
+    def submit_connection(socket, app, max_request_read_seconds: 60)
+      return false if @max_pending && @inbox.size >= @max_pending
+
+      @inbox << [:connection, socket, app, max_request_read_seconds]
+      true
     end
 
     # HTTP/2 + sub-call path: hop one `app.call` from the calling fiber to a
@@ -78,12 +94,12 @@ module Hyperion
 
           case job[0]
           when :connection
-            _, socket, app = job
+            _, socket, app, max_request_read_seconds = job
             # Worker thread owns the connection for its full lifetime. Pass
             # thread_pool: nil so Connection#call_app inlines Adapter::Rack.call
             # — the worker IS the pool, no further hop required.
             begin
-              Hyperion::Connection.new.serve(socket, app)
+              Hyperion::Connection.new.serve(socket, app, max_request_read_seconds: max_request_read_seconds)
             rescue StandardError => e
               Hyperion.logger.error do
                 {

data/lib/hyperion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hyperion
-  VERSION = '1.0.1'
+  VERSION = '1.2.0'
 end

data/lib/hyperion/worker.rb

@@ -18,16 +18,21 @@ module Hyperion
   class Worker
     def initialize(host:, port:, app:, read_timeout:, tls: nil,
                    thread_count: Server::DEFAULT_THREAD_COUNT,
-                   config: nil, worker_index: 0, listener: nil)
-      @host         = host
-      @port         = port
-      @app          = app
-      @read_timeout = read_timeout
-      @tls          = tls
-      @thread_count = thread_count
-      @config       = config || Hyperion::Config.new
-      @worker_index = worker_index
-      @listener     = listener
+                   config: nil, worker_index: 0, listener: nil,
+                   max_pending: nil, max_request_read_seconds: 60,
+                   h2_settings: nil)
+      @host                     = host
+      @port                     = port
+      @app                      = app
+      @read_timeout             = read_timeout
+      @tls                      = tls
+      @thread_count             = thread_count
+      @config                   = config || Hyperion::Config.new
+      @worker_index             = worker_index
+      @listener                 = listener
+      @max_pending              = max_pending
+      @max_request_read_seconds = max_request_read_seconds
+      @h2_settings              = h2_settings
     end
 
     def run
@@ -43,7 +48,10 @@ module Hyperion
 
       server = Server.new(host: @host, port: @port, app: @app,
                           read_timeout: @read_timeout, tls: @tls,
-                          thread_count: @thread_count)
+                          thread_count: @thread_count,
+                          max_pending: @max_pending,
+                          max_request_read_seconds: @max_request_read_seconds,
+                          h2_settings: @h2_settings)
       tcp_server = @listener || build_reuseport_listener
       server.adopt_listener(tcp_server)
 

data/lib/hyperion/worker_health.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Hyperion
+  # Measures a worker process's resident set size (RSS) in MiB.
+  # Cross-platform: uses /proc/<pid>/statm on Linux (zero subprocess) and
+  # `ps -o rss= -p <pid>` everywhere else (macOS, BSD).
+  module WorkerHealth
+    module_function
+
+    # Returns the worker's RSS in MiB, or nil if it can't be read (process
+    # gone, ps not available, /proc not mounted). Callers must handle nil
+    # gracefully — health checks must never crash the supervisor.
+    def rss_mb(pid)
+      if File.readable?("/proc/#{pid}/statm")
+        # statm fields are in pages; column index 1 is "resident".
+        # PAGE_SIZE = 4096 on x86_64 / aarch64 Linux.
+        contents = File.read("/proc/#{pid}/statm")
+        pages = contents.split.fetch(1).to_i
+        bytes = pages * 4096
+        bytes / 1024 / 1024
+      else
+        # Fallback: ps emits RSS in KiB.
+        out = `ps -o rss= -p #{pid} 2>/dev/null`
+        kib = out.strip.to_i
+        return nil if kib.zero?
+
+        kib / 1024
+      end
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/hyperion.rb

@@ -25,6 +25,23 @@ module Hyperion
       metrics.snapshot
     end
 
+    # Whether YJIT is currently enabled in this Ruby process. False on Rubies
+    # that don't ship YJIT (JRuby, TruffleRuby) and on CRuby builds compiled
+    # without YJIT support. Cheap (no allocations) — safe to call from hot
+    # paths if needed for diagnostics.
+    def yjit_enabled?
+      defined?(::RubyVM::YJIT) && ::RubyVM::YJIT.enabled?
+    end
+
+    # Whether the llhttp C extension loaded. False on JRuby/TruffleRuby and
+    # any environment where extconf.rb / make failed at install time. The
+    # pure-Ruby parser handles those cases correctly but is ~2× slower on
+    # parse-heavy workloads. Operators running production should confirm this
+    # returns true; CLI emits a startup banner if it doesn't.
+    def c_parser_available?
+      defined?(::Hyperion::CParser) && ::Hyperion::CParser.respond_to?(:build_response_head)
+    end
+
     # Per-request access logging is ON by default — matches Puma/Rails operator
     # expectations (Rails::Rack::Logger emits one line per request out of the
     # box). Operators can disable it via `--no-log-requests`,
@@ -46,6 +63,44 @@ module Hyperion
         else true # default ON
         end
     end
+
+    # Pre-fork warmup. Run by Master and CLI single-mode BEFORE children are
+    # forked (or before the lone worker starts accepting). Pre-allocates the
+    # Rack adapter's object pools and eager-touches lazily-resolved constants
+    # so each forked child inherits warm memory via copy-on-write — the first
+    # N requests on a fresh worker no longer pay the allocation / autoload
+    # tax that would otherwise serialize behind the GVL on cold start.
+    #
+    # Idempotent — second and later calls are no-ops. Failures are swallowed
+    # with a warn log: warmup is an optimization, not a correctness gate.
+    # If, for instance, OpenSSL can't be required in some odd environment,
+    # we'd rather start cold than refuse to boot.
+    def warmup!
+      return if @warmed
+
+      @warmed = true
+
+      if defined?(::Hyperion::Adapter::Rack) && ::Hyperion::Adapter::Rack.respond_to?(:warmup_pool)
+        ::Hyperion::Adapter::Rack.warmup_pool(8)
+      end
+
+      # Touch the C extension's response-head builder so its lazily-initialized
+      # internal state runs in the master, not in every child after fork.
+      ::Hyperion::CParser.respond_to?(:build_response_head) if defined?(::Hyperion::CParser)
+
+      # Eager-load TLS / SSLSocket. The sendfile path's `is_a?` check would
+      # otherwise trigger autoload in the worker on the first TLS response.
+      require 'openssl'
+      defined?(::OpenSSL::SSL::SSLSocket) && ::OpenSSL::SSL::SSLSocket.name
+
+      # Force Ruby's tzinfo / strftime-cache load by emitting one httpdate.
+      # Subsequent calls hit the per-thread `cached_date` slot in response_writer.
+      Time.now.httpdate
+      nil
+    rescue StandardError => e
+      Hyperion.logger.warn { { message: 'warmup failed (non-fatal)', error: e.message } }
+      nil
+    end
   end
 end
 
@@ -72,6 +127,8 @@ require_relative 'hyperion/request'
 require_relative 'hyperion/parser'
 require_relative 'hyperion/c_parser'
 require_relative 'hyperion/adapter/rack'
+require_relative 'hyperion/prometheus_exporter'
+require_relative 'hyperion/admin_middleware'
 require_relative 'hyperion/response_writer'
 require_relative 'hyperion/thread_pool'
 require_relative 'hyperion/connection'
@@ -79,4 +136,5 @@ require_relative 'hyperion/tls'
 require_relative 'hyperion/http2_handler'
 require_relative 'hyperion/server'
 require_relative 'hyperion/worker'
+require_relative 'hyperion/worker_health'
 require_relative 'hyperion/master'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hyperion-rb
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Andrey Lobanov
@@ -148,6 +148,7 @@ files:
 - lib/hyperion-rb.rb
 - lib/hyperion.rb
 - lib/hyperion/adapter/rack.rb
+- lib/hyperion/admin_middleware.rb
 - lib/hyperion/c_parser.rb
 - lib/hyperion/cli.rb
 - lib/hyperion/config.rb
@@ -159,6 +160,7 @@ files:
 - lib/hyperion/metrics.rb
 - lib/hyperion/parser.rb
 - lib/hyperion/pool.rb
+- lib/hyperion/prometheus_exporter.rb
 - lib/hyperion/request.rb
 - lib/hyperion/response_writer.rb
 - lib/hyperion/server.rb
@@ -166,6 +168,7 @@ files:
 - lib/hyperion/tls.rb
 - lib/hyperion/version.rb
 - lib/hyperion/worker.rb
+- lib/hyperion/worker_health.rb
 homepage: https://github.com/andrew-woblavobla/hyperion
 licenses:
 - MIT