igniter 0.4.3 → 0.5.0

data/lib/igniter/server/handlers/liveness_handler.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    module Handlers
+      # GET /v1/live — Kubernetes liveness probe.
+      #
+      # Returns 200 as long as the process is running. This endpoint should
+      # NEVER return a non-200 status unless the process is truly broken (e.g.
+      # deadlocked). A failing liveness probe causes K8s to restart the pod.
+      class LivenessHandler < Base
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
+          json_ok({ status: "alive", pid: Process.pid })
+        end
+      end
+    end
+  end
+end

data/lib/igniter/server/handlers/manifest_handler.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    module Handlers
+      # Returns a JSON manifest describing this peer: its name, advertised
+      # capabilities, registered contracts, and its base URL.
+      # Used by Igniter::Mesh::Router health-probing and peer discovery.
+      class ManifestHandler < Base
+        def initialize(registry, store, config: nil)
+          super(registry, store)
+          @config = config
+        end
+
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
+          json_ok({
+                    peer_name: @config&.peer_name,
+                    capabilities: (@config&.peer_capabilities || []).map(&:to_s),
+                    contracts: @registry.names,
+                    url: node_url
+                  })
+        end
+
+        def node_url
+          return nil unless @config
+
+          "http://#{@config.host}:#{@config.port}"
+        end
+      end
+    end
+  end
+end

data/lib/igniter/server/handlers/metrics_handler.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "igniter/metrics"
+
+module Igniter
+  module Server
+    module Handlers
+      # GET /v1/metrics — Prometheus text format metrics endpoint.
+      #
+      # Requires a Collector to be configured on the server:
+      #   Igniter::Server.configure { |c| c.metrics_collector = Igniter::Metrics::Collector.new }
+      #
+      # When no collector is configured, returns a 501 Not Implemented response.
+      class MetricsHandler < Base
+        def initialize(registry, store, collector:)
+          super(registry, store)
+          @collector = collector
+        end
+
+        # Override Base#call to return Prometheus text/plain instead of JSON.
+        def call(params:, body:)
+          handle(params: params, body: body)
+        rescue StandardError => e
+          { status: 500,
+            body: "# ERROR: #{e.message}\n",
+            headers: { "Content-Type" => Igniter::Metrics::PrometheusExporter::CONTENT_TYPE } }
+        end
+
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
+          unless @collector
+            return { status: 501,
+                     body: JSON.generate({ error: "metrics_collector not configured" }),
+                     headers: { "Content-Type" => "application/json" } }
+          end
+
+          exporter = Igniter::Metrics::PrometheusExporter.new(
+            @collector,
+            store: @store,
+            registry: @registry
+          )
+
+          { status: 200,
+            body: exporter.export,
+            headers: { "Content-Type" => exporter.content_type } }
+        end
+      end
+    end
+  end
+end

data/lib/igniter/server/handlers/peers_handler.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Igniter
+  module Server
+    module Handlers
+      # Shared helper — merges static (add_peer) and dynamic (PeerRegistry) peer pools.
+      # Static entries take precedence when the same name appears in both pools.
+      module MeshPeersMerger
+        private
+
+        def merged_peers
+          return [] unless defined?(Igniter::Mesh)
+
+          static  = Igniter::Mesh.config.peers
+          dynamic = Igniter::Mesh.config.peer_registry.all
+          seen    = static.each_with_object({}) { |p, h| h[p.name] = true }
+          static + dynamic.reject { |p| seen[p.name] }
+        end
+      end
+
+      # GET /v1/mesh/peers
+      # Returns the merged list of static + dynamically discovered peers.
+      class MeshPeersListHandler < Base
+        include MeshPeersMerger
+
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
+          json_ok(merged_peers.map do |p|
+            { "name" => p.name, "url" => p.url, "capabilities" => p.capabilities.map(&:to_s) }
+          end)
+        end
+      end
+
+      # GET /v1/mesh/sd
+      # Returns the peer list in Prometheus HTTP SD format so that Prometheus can
+      # dynamically discover all igniter-server scrape targets without a static target list.
+      #
+      # Response shape (one object per peer):
+      #   [{ "targets" => ["host:port"], "labels" => { "__meta_igniter_peer_name" => ..., ... } }]
+      #
+      # Usage in prometheus.yml:
+      #   scrape_configs:
+      #     - job_name: igniter
+      #       http_sd_configs:
+      #         - url: http://any-seed:4567/v1/mesh/sd
+      #           refresh_interval: 30s
+      #       metrics_path: /v1/metrics
+      class MeshSdHandler < Base
+        include MeshPeersMerger
+
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
+          json_ok(merged_peers.map { |p| sd_entry(p) })
+        end
+
+        def sd_entry(peer)
+          {
+            "targets" => [host_port(peer.url)],
+            "labels" => {
+              "__meta_igniter_peer_name" => peer.name,
+              "__meta_igniter_capabilities" => peer.capabilities.map(&:to_s).join(",")
+            }
+          }
+        end
+
+        def host_port(url)
+          uri = URI.parse(url)
+          "#{uri.host}:#{uri.port}"
+        rescue URI::InvalidURIError
+          url
+        end
+      end
+
+      # POST /v1/mesh/peers
+      # Body: { "name": "peer-name", "url": "http://host:port", "capabilities": ["a", "b"] }
+      class MeshPeersRegisterHandler < Base
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument, Metrics/AbcSize
+          return json_error("Igniter::Mesh is not loaded", status: 422) unless defined?(Igniter::Mesh)
+
+          name = body["name"].to_s.strip
+          url  = body["url"].to_s.strip
+          return json_error("name is required", status: 400) if name.empty?
+          return json_error("url is required",  status: 400) if url.empty?
+
+          caps = Array(body["capabilities"]).map(&:to_sym)
+          peer = Igniter::Mesh::Peer.new(name: name, url: url, capabilities: caps)
+          Igniter::Mesh.config.peer_registry.register(peer)
+
+          json_ok({ "registered" => true, "name" => name })
+        end
+      end
+
+      # DELETE /v1/mesh/peers/:name
+      # Idempotent — no error if the peer was not registered.
+      class MeshPeersDeleteHandler < Base
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
+          return json_error("Igniter::Mesh is not loaded", status: 422) unless defined?(Igniter::Mesh)
+
+          name = params[:name].to_s
+          Igniter::Mesh.config.peer_registry.unregister(name)
+
+          json_ok({ "unregistered" => true, "name" => name })
+        end
+      end
+    end
+  end
+end

data/lib/igniter/server/handlers/readiness_handler.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    module Handlers
+      # GET /v1/ready — Kubernetes readiness probe.
+      #
+      # Returns 200 when the server is ready to accept traffic:
+      #   - Store is reachable (list_pending does not raise)
+      #   - At least one contract is registered
+      #
+      # Returns 503 when the server should be removed from the load balancer
+      # rotation but NOT restarted. A failing readiness probe causes K8s to
+      # stop routing traffic to the pod without killing it.
+      class ReadinessHandler < Base
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument,Metrics/MethodLength
+          checks = {}
+
+          # Store connectivity check
+          checks[:store] = check_store
+
+          # Contract registration check
+          checks[:contracts] = @registry.names.any? ? "ok" : "no_contracts_registered"
+
+          if checks.values.all? { |v| v == "ok" }
+            json_ok({ status: "ready", checks: checks })
+          else
+            service_unavailable({ status: "not_ready", checks: checks })
+          end
+        end
+
+        def check_store
+          @store.list_pending(graph: nil)
+          "ok"
+        rescue StandardError => e
+          "error: #{e.message}"
+        end
+
+        def service_unavailable(data)
+          { status: 503, body: JSON.generate(data), headers: { "Content-Type" => "application/json" } }
+        end
+      end
+    end
+  end
+end

data/lib/igniter/server/http_server.rb

@@ -7,29 +7,35 @@ module Igniter
     # Pure-Ruby HTTP/1.1 server built on TCPServer (stdlib, zero external deps).
     # Spawns one thread per connection. Intended for development and orchestration use.
     # For production, use RackApp with Puma via `Igniter::Server.rack_app`.
-    class HttpServer
+    class HttpServer # rubocop:disable Metrics/ClassLength
       CRLF = "\r\n"
       STATUS_MESSAGES = {
         200 => "OK",
         400 => "Bad Request",
         404 => "Not Found",
         422 => "Unprocessable Entity",
-        500 => "Internal Server Error"
+        500 => "Internal Server Error",
+        501 => "Not Implemented",
+        503 => "Service Unavailable"
       }.freeze
 
       def initialize(config)
-        @config = config
-        @router = Router.new(config)
+        @config       = config
+        @router       = Router.new(config)
+        @logger       = ServerLogger.new(format: config.log_format)
+        @in_flight    = 0
+        @in_flight_mu = Mutex.new
       end
 
-      def start # rubocop:disable Metrics/MethodLength
+      def start # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
         @tcp_server = TCPServer.new(@config.host, @config.port)
         @running    = true
 
         trap("INT")  { stop }
-        trap("TERM") { stop }
+        trap("TERM") { graceful_stop }
 
-        log("igniter-server listening on http://#{@config.host}:#{@config.port}")
+        @logger.info("igniter-server started",
+                     host: @config.host, port: @config.port, pid: Process.pid)
 
         loop do
           break unless @running
@@ -39,6 +45,9 @@ module Igniter
         end
       rescue IOError
         # Server socket closed via stop
+      ensure
+        drain_in_flight
+        @logger.info("igniter-server stopped", pid: Process.pid)
       end
 
       def stop
@@ -46,6 +55,13 @@ module Igniter
         @tcp_server&.close
       end
 
+      def graceful_stop
+        @logger.info("SIGTERM received — draining",
+                     drain_timeout: @config.drain_timeout, pid: Process.pid)
+        @running = false
+        @tcp_server&.close
+      end
+
       private
 
       def accept_connection
@@ -57,7 +73,7 @@ module Igniter
         nil
       end
 
-      def handle_connection(socket) # rubocop:disable Metrics/MethodLength
+      def handle_connection(socket) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
         request_line = socket.gets&.chomp
         return unless request_line&.include?(" ")
 
@@ -65,14 +81,38 @@ module Igniter
         headers = read_headers(socket)
         body    = read_body(socket, headers["content-length"].to_i)
 
-        result = @router.call(http_method, path, body)
-        write_response(socket, result)
+        with_in_flight do
+          result = @router.call(http_method, path, body)
+          write_response(socket, result)
+          @logger.info("#{http_method} #{path}", status: result[:status])
+        end
       rescue StandardError => e
-        log("Connection error: #{e.message}")
+        @logger.error("Connection error", error: e.message)
       ensure
         socket.close rescue nil # rubocop:disable Style/RescueModifier
       end
 
+      def with_in_flight
+        @in_flight_mu.synchronize { @in_flight += 1 }
+        yield
+      ensure
+        @in_flight_mu.synchronize { @in_flight -= 1 }
+      end
+
+      def drain_in_flight
+        timeout  = @config.drain_timeout.to_i
+        deadline = Time.now + timeout
+
+        loop do
+          remaining = @in_flight_mu.synchronize { @in_flight }
+          break if remaining.zero?
+          break if Time.now > deadline
+
+          @logger.info("Draining in-flight connections", remaining: remaining)
+          sleep 0.1
+        end
+      end
+
       def read_headers(socket)
         headers = {}
         while (line = socket.gets&.chomp) && !line.empty?
@@ -86,13 +126,14 @@ module Igniter
         length.positive? ? socket.read(length).to_s : ""
       end
 
-      def write_response(socket, result)
+      def write_response(socket, result) # rubocop:disable Metrics/MethodLength
         body   = result[:body].to_s
         code   = result[:status].to_i
         phrase = STATUS_MESSAGES.fetch(code, "Unknown")
+        ct     = result.dig(:headers, "Content-Type") || "application/json"
 
         response  = "HTTP/1.1 #{code} #{phrase}#{CRLF}"
-        response += "Content-Type: application/json#{CRLF}"
+        response += "Content-Type: #{ct}#{CRLF}"
         response += "Content-Length: #{body.bytesize}#{CRLF}"
         response += "Connection: close#{CRLF}"
         response += CRLF
@@ -100,10 +141,6 @@ module Igniter
 
         socket.write(response)
       end
-
-      def log(message)
-        @config.logger&.puts(message) || $stdout.puts(message)
-      end
     end
   end
 end

data/lib/igniter/server/router.rb

@@ -9,54 +9,87 @@ module Igniter
     # Used by both HttpServer (TCPServer) and RackApp.
     class Router
       ROUTES = [
-        { method: "GET",  pattern: %r{\A/v1/health\z}, handler: :health },
-        { method: "GET",  pattern: %r{\A/v1/contracts\z},                             handler: :contracts },
-        { method: "POST", pattern: %r{\A/v1/contracts/(?<name>[^/]+)/execute\z},      handler: :execute },
-        { method: "POST", pattern: %r{\A/v1/contracts/(?<name>[^/]+)/events\z},       handler: :event },
-        { method: "GET",  pattern: %r{\A/v1/executions/(?<id>[^/]+)\z},               handler: :status }
+        { method: "GET",    pattern: %r{\A/v1/live\z},                             handler: :liveness },
+        { method: "GET",    pattern: %r{\A/v1/ready\z},                            handler: :readiness },
+        { method: "GET",    pattern: %r{\A/v1/metrics\z},                          handler: :metrics },
+        { method: "GET",    pattern: %r{\A/v1/health\z},                           handler: :health },
+        { method: "GET",    pattern: %r{\A/v1/manifest\z},                         handler: :manifest },
+        { method: "GET",    pattern: %r{\A/v1/mesh/peers\z},                       handler: :mesh_peers_list },
+        { method: "GET",    pattern: %r{\A/v1/mesh/sd\z}, handler: :mesh_sd },
+        { method: "POST",   pattern: %r{\A/v1/mesh/peers\z},                       handler: :mesh_peers_register },
+        { method: "DELETE", pattern: %r{\A/v1/mesh/peers/(?<name>.+)\z},           handler: :mesh_peers_delete },
+        { method: "GET",    pattern: %r{\A/v1/contracts\z},                        handler: :contracts },
+        { method: "POST",   pattern: %r{\A/v1/contracts/(?<name>[^/]+)/execute\z}, handler: :execute },
+        { method: "POST",   pattern: %r{\A/v1/contracts/(?<name>[^/]+)/events\z},  handler: :event },
+        { method: "GET",    pattern: %r{\A/v1/executions/(?<id>[^/]+)\z},          handler: :status }
       ].freeze
 
       def initialize(config)
         @config = config
       end
 
-      # Main dispatch entry point — called by both WEBrick and Rack adapters.
+      # Main dispatch entry point — called by both HttpServer and RackApp.
+      # Records HTTP metrics when a collector is configured.
       def call(http_method, path, body_str) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
-        method_uc = http_method.to_s.upcase
+        started_at = Time.now.utc
+        method_uc  = http_method.to_s.upcase
+
         ROUTES.each do |route|
           next unless route[:method] == method_uc
 
           match = route[:pattern].match(path)
           next unless match
 
-          params = match.named_captures.transform_keys(&:to_sym)
-          body   = parse_body(body_str)
-
+          params  = match.named_captures.transform_keys(&:to_sym)
+          body    = parse_body(body_str)
           handler = build_handler(route[:handler])
-          return handler.call(params: params, body: body)
+          result  = handler.call(params: params, body: body)
+
+          record_http_metric(method_uc, path, result[:status], started_at)
+          return result
         end
 
-        not_found_response(path)
+        result = not_found_response(path)
+        record_http_metric(method_uc, path, 404, started_at)
+        result
       rescue JSON::ParserError => e
         { status: 400, body: JSON.generate({ error: "Invalid JSON: #{e.message}" }), headers: json_ct }
       end
 
       private
 
-      def build_handler(key)
-        registry = @config.registry
-        store    = @config.store
-        node_url = "http://#{@config.host}:#{@config.port}"
+      def build_handler(key) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+        registry  = @config.registry
+        store     = @config.store
+        node_url  = "http://#{@config.host}:#{@config.port}"
+        collector = @config.metrics_collector
 
         case key
-        when :health     then Handlers::HealthHandler.new(registry, store, node_url: node_url)
-        when :contracts  then Handlers::ContractsHandler.new(registry, store)
-        when :execute    then Handlers::ExecuteHandler.new(registry, store)
-        when :event      then Handlers::EventHandler.new(registry, store)
-        when :status     then Handlers::StatusHandler.new(registry, store)
+        when :liveness           then Handlers::LivenessHandler.new(registry, store)
+        when :readiness          then Handlers::ReadinessHandler.new(registry, store)
+        when :metrics            then Handlers::MetricsHandler.new(registry, store, collector: collector)
+        when :health             then Handlers::HealthHandler.new(registry, store, node_url: node_url)
+        when :manifest           then Handlers::ManifestHandler.new(registry, store, config: @config)
+        when :mesh_peers_list    then Handlers::MeshPeersListHandler.new(registry, store)
+        when :mesh_sd            then Handlers::MeshSdHandler.new(registry, store)
+        when :mesh_peers_register then Handlers::MeshPeersRegisterHandler.new(registry, store)
+        when :mesh_peers_delete  then Handlers::MeshPeersDeleteHandler.new(registry, store)
+        when :contracts          then Handlers::ContractsHandler.new(registry, store)
+        when :execute            then Handlers::ExecuteHandler.new(registry, store, collector: collector)
+        when :event              then Handlers::EventHandler.new(registry, store, collector: collector)
+        when :status             then Handlers::StatusHandler.new(registry, store)
         end
       end
 
+      def record_http_metric(method, path, status, started_at)
+        return unless @config.metrics_collector
+
+        duration = Time.now.utc - started_at
+        @config.metrics_collector.record_http(
+          method: method, path: path, status: status, duration: duration
+        )
+      end
+
       def parse_body(str)
         return {} if str.nil? || str.strip.empty?
 

data/lib/igniter/server/server_logger.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Igniter
+  module Server
+    # Minimal structured logger for igniter-server.
+    #
+    # format: :json  → each line is a JSON object (Loki/ELK/CloudWatch compatible)
+    # format: :text  → human-readable single-line string
+    #
+    # Thread-safe via an internal Mutex.
+    class ServerLogger
+      def initialize(format: :text, out: $stdout)
+        @format = format
+        @out    = out
+        @mutex  = Mutex.new
+      end
+
+      def info(message, **context)
+        log("INFO", message, context)
+      end
+
+      def warn(message, **context)
+        log("WARN", message, context)
+      end
+
+      def error(message, **context)
+        log("ERROR", message, context)
+      end
+
+      private
+
+      def log(level, message, context)
+        line = @format == :json ? json_line(level, message, context) : text_line(level, message, context)
+        @mutex.synchronize { @out.puts(line) }
+      end
+
+      def json_line(level, message, context)
+        JSON.generate(
+          { time: Time.now.utc.iso8601(3), level: level, msg: message }.merge(context)
+        )
+      end
+
+      def text_line(level, message, context)
+        ts    = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+        extra = context.empty? ? "" : " #{context.map { |k, v| "#{k}=#{v}" }.join(" ")}"
+        "[#{ts}] #{level} #{message}#{extra}"
+      end
+    end
+  end
+end

data/lib/igniter/server.rb

@@ -12,6 +12,7 @@ module Igniter
 end
 
 require_relative "server/registry"
+require_relative "server/server_logger"
 require_relative "server/config"
 require_relative "server/router"
 require_relative "server/http_server"
@@ -23,6 +24,11 @@ require_relative "server/handlers/contracts_handler"
 require_relative "server/handlers/execute_handler"
 require_relative "server/handlers/event_handler"
 require_relative "server/handlers/status_handler"
+require_relative "server/handlers/liveness_handler"
+require_relative "server/handlers/readiness_handler"
+require_relative "server/handlers/metrics_handler"
+require_relative "server/handlers/manifest_handler"
+require_relative "server/handlers/peers_handler"
 
 module Igniter
   module Server