zapp 0.1.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f666d4681200fdaf226cf78821e61fad6192f61f70bf8db9aa70a6c224a6a1e6
-  data.tar.gz: c6c72378e757c93190b5c2e73ec83c87806ba3d13f1bc80670336605be538d7c
+  metadata.gz: 6b4a4b6bdf9ac52a419e899e41344faf5ff15fdde704f70e93fe71cee334e70e
+  data.tar.gz: 4bd738d7ca1919ceef29612c5bf9a07a26ad8bda944b9adfc52197435dbb1a0a
 SHA512:
-  metadata.gz: ce692ed7205e2aa7157bf7180caf8d2c30ed973a394181f340dc456ef220ced24773bfe4cfa2e98a3cd5083e193cefb47b4daa043af9bb682878738e477e8576
-  data.tar.gz: 978c754d57a872141d03f8d522c94dab93ee94807cd2a09266cb1b223411b9e6bec0656e92a0750276847375c865755c4fea67547adbd6b1c6c5d16fc16264f5
+  metadata.gz: 26554e64959a88e35bf1b7f9657909da61de5a92c980550df415ae0b5564f899b25922e1fbb69d79a39a72506fe903654a007555c8e85ce3b437eb1cbbf8ccb3
+  data.tar.gz: c790f81f5fa7d1867ee6f33c3fff92f3df44ece8051e9dc3f9ed260724dd0236a3d3fd1814ba3dcf54f3743713782445a5001f54fcb275872943665055593b64

data/.rubocop.yml

@@ -5,12 +5,17 @@ AllCops:
   Exclude:
     - examples/**/*
 
+Gemspec/RequireMFA:
+  Enabled: false
+
 Style/DocumentationMethod:
   Enabled: false
 Style/MissingElse:
   Enabled: false
 Style/StringLiterals:
   EnforcedStyle: double_quotes
+Style/InlineComment:
+  Enabled: false
 Style/Copyright:
   Enabled: false
 Style/ConstantVisibility:

data/Gemfile.lock

@@ -1,19 +1,20 @@
 PATH
   remote: .
   specs:
-    zapp (0.1.0)
+    zapp (0.2.1)
       concurrent-ruby (~> 1.1.9)
       puma (~> 5.5.2)
       rack (~> 2.2.3)
       rake (~> 13.0)
       rspec (~> 3.0)
+      webrick
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
     coderay (1.1.3)
-    concurrent-ruby (1.1.9)
+    concurrent-ruby (1.1.10)
     diff-lcs (1.4.4)
     docile (1.4.0)
     ffi (1.15.4)
@@ -53,7 +54,7 @@ GEM
       method_source (~> 1.0)
     puma (5.5.2)
       nio4r (~> 2.0)
-    rack (2.2.3)
+    rack (2.2.4)
     rainbow (3.0.0)
     rake (13.0.6)
     rb-fsevent (0.11.0)
@@ -95,6 +96,7 @@ GEM
     simplecov_json_formatter (0.1.3)
     thor (1.1.0)
     unicode-display_width (2.1.0)
+    webrick (1.7.0)
 
 PLATFORMS
   x86_64-linux

data/bin/zapp

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require("bundler/setup")
-require("zapp")
+require_relative("../lib/zapp")
 
 Zapp::CLI.new.run

data/examples/config/app.rb

@@ -0,0 +1,5 @@
+class App
+  def self.call(env)
+    [200, {}, ["Hello from Zapp", env.to_s]]
+  end
+end

data/examples/config/puma.rb

@@ -0,0 +1,10 @@
+require_relative("app")
+
+max_threads_count = ENV.fetch("RAILS_MAX_THREADS", 5)
+min_threads_count = ENV.fetch("RAILS_MIN_THREADS") { max_threads_count }
+threads(min_threads_count, max_threads_count)
+worker_timeout(3600) if ENV.fetch("RAILS_ENV", "development") == "development"
+port(ENV.fetch("PORT", 3000))
+environment(ENV.fetch("RAILS_ENV", "development"))
+workers ENV.fetch("WEB_CONCURRENCY") { 2 }
+app(App)

data/examples/config/zapp.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require("json")
+
+class App
+  def self.call(env)
+    [200, {}, ["Hello from Zapp", JSON.generate(env)]]
+  end
+end
+
+parallelism(4)
+threads_per_worker(25)
+app(App)

data/lib/rack/handler/{zap.rb → zapp.rb}

@@ -6,11 +6,12 @@ module Rack
   module Handler
     # Rack handler for the Zapp web server
     class Zapp
+      register(:zapp, Rack::Handler::Zapp)
+
       def self.run(app)
-        Zapp::Server.new(app: app).run
+        Zapp.config.app = app
+        Zapp::Server.new.run
       end
-
-      register(:zapp, Rack::Handler::Zapp)
     end
   end
 end

data/lib/zapp/cli.rb

@@ -27,6 +27,11 @@ module Zapp
           parse_config_file(location: file)
         end
 
+        opts.on("-v", "--version", "Prints the version of Zapp currently running") do
+          puts("Zapp v#{Zapp::VERSION}")
+          exit
+        end
+
         opts.on("-h", "--help", "Prints this help") do
           puts(opts)
           exit

data/lib/zapp/configuration.rb

@@ -12,6 +12,7 @@ module Zapp
       :parallelism,
       :threads_per_worker,
       :logger_class,
+      :logger_out_io,
       :log_requests,
       :log_uncaught_errors,
       :host,
@@ -33,6 +34,7 @@ module Zapp
 
       # Default logging behavior
       logger_class: Zapp::Logger,
+      logger_out_io: $stdout,
       log_requests: true,
       log_uncaught_errors: true,
 
@@ -44,7 +46,7 @@ module Zapp
         {
           Rack::RACK_VERSION => Rack::VERSION,
           Rack::RACK_ERRORS => $stderr,
-          Rack::RACK_MULTITHREAD => false,
+          Rack::RACK_MULTITHREAD => true,
           Rack::RACK_MULTIPROCESS => true,
           Rack::RACK_RUNONCE => false,
           Rack::RACK_URL_SCHEME => %w[yes on 1].include?(ENV["HTTPS"]) ? "https" : "http"
@@ -72,7 +74,7 @@ module Zapp
       @app = new unless new.nil?
 
       @app ||= begin
-        raise(Zapp::ZapError, "Missing rackup file '#{rackup_file}'") unless File.exist?(rackup_file)
+        raise(Zapp::ZappError, "Missing rackup file '#{rackup_file}'") unless File.exist?(rackup_file)
 
         rack_app, = rack_builder.parse_file(rackup_file)
 
@@ -98,6 +100,12 @@ module Zapp
       @logger_class = new
     end
 
+    def logger_out_io(new = nil)
+      return @logger_out_io if new.nil?
+
+      @logger_out_io = new
+    end
+
     def log_requests(new = nil)
       return @log_requests if new.nil?
 

data/lib/zapp/http_context/context.rb

@@ -1,31 +1,30 @@
 # frozen_string_literal: true
 
-require("zapp/http_context/request")
-require("zapp/http_context/response")
+require_relative("request")
+require_relative("response")
 
 module Zapp
   module HTTPContext
     # Context containing request and response
     class Context
-      attr_reader(:req, :res)
+      attr_reader(:req, :res, :socket)
 
-      def initialize(socket:)
+      def initialize(socket:, logger: Zapp::Logger)
         @socket = socket
         @req = Zapp::HTTPContext::Request.new(socket: socket)
         @res = Zapp::HTTPContext::Response.new(socket: socket)
+      rescue Puma::HttpParserError => e
+        res.write(data: "Invalid HTTP request", status: 400, headers: {})
+        logger.warn("Puma parser error: #{e}")
+        logger.debug("HTTP request raw: #{context.req.raw}")
       end
 
       def close
         @socket.close
       end
 
-      def dup
-        clone_context = super
-        clone_context.instance_variable_set(:@req, @req.dup)
-        clone_context.instance_variable_set(:@res, @res.dup)
-        clone_context.instance_variable_set(:@socket, @socket.dup)
-
-        clone_context
+      def client_closed?
+        req.data["HTTP_CONNECTION"] == "close"
       end
     end
   end

data/lib/zapp/http_context/request.rb

@@ -1,27 +1,31 @@
 # frozen_string_literal: true
 
+require("webrick")
+
 module Zapp
   module HTTPContext
     # Represents an HTTP Request to be processed by a worker
     class Request
       attr_reader(:raw, :data, :body)
 
-      def initialize(socket:)
-        raise(EOFError) if socket.eof?
+      # Request parsing is done threaded, but not in separate Ractors.
+      # So we allocate an HTTP parser per thread and assign it to this hash key in Thread.current
+      PARSER_THREAD_HASH_KEY = "PUMA_PARSER_INSTANCE"
 
+      def initialize(socket:)
         # Max Request size of 8KB TODO: Make a config value for this setting
         @raw = socket.readpartial(8192)
         @data = {}
-      end
 
-      def parse!(parser: Puma::HttpParser.new)
         parser.execute(data, raw, 0)
+
         @body = Zapp::InputStream.new(string: parser.body)
+
         parser.reset
       end
 
-      def parsed?
-        body.is_a?(Zapp::InputStream) && !data.nil? && data != {}
+      def parser
+        Thread.current[PARSER_THREAD_HASH_KEY] ||= Puma::HttpParser.new
       end
     end
   end

data/lib/zapp/http_context/response.rb

@@ -4,21 +4,26 @@ module Zapp
   module HTTPContext
     # Represents an HTTP response being sent back to a client
     class Response
+      attr_reader(:status, :data, :headers)
+
       def initialize(socket:)
         @socket = socket
       end
 
-      # TODO: Add headers argument
       def write(data:, status:, headers:)
-        response = "HTTP/1.1 #{status}\n"
+        @status = status
+        @data = data
+        @headers = headers
+
+        response = +"HTTP/1.1 #{status}\n"
 
-        response += "Content-Length: #{data.size}\n" unless headers["Content-Length"]
+        response << "Content-Length: #{data.size}\n" unless headers["Content-Length"]
 
         headers.each do |k, v|
-          response += "#{k}: #{v}\n"
+          response << "#{k}: #{v}\n"
         end
 
-        response += "\n#{data}\n"
+        response << "\n#{data}\n"
 
         @socket.write(response)
       end

data/lib/zapp/logger/base.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Zapp
+  class Logger
+    # Base contains all the logging functionality and is included both as class and instance methods of Zap::Logger
+    # This allows logging without creating new instances,
+    # while allowing Ractors to create their own instances for thread safety
+    module Base
+      attr_writer(:level, :prefix)
+
+      LEVELS = { TRACE: 0, DEBUG: 1, INFO: 2, WARN: 3, ERROR: 4 }.freeze
+
+      FROZEN_ENV = ENV.map { |k, v| [k.freeze, v.freeze] }
+                      .to_h.freeze
+
+      # The hash key in Ractor.current that stores the mutex for writing to output
+      OUT_IO_MUTEX_KEY = "ZAPP_LOGGER_OUT_IO_MUTEX"
+
+      def trace(msg) = log("TRACE", msg)
+
+      def debug(msg) = log("DEBUG", msg)
+
+      def info(msg) = log("INFO", msg)
+
+      def warn(msg) = log("WARN", msg)
+
+      def error(msg) = log("ERROR", msg)
+
+      def level
+        @level ||= begin
+          log_level = FROZEN_ENV["LOG_LEVEL"]
+
+          if log_level == "" || log_level.nil?
+            LEVELS[:DEBUG]
+          else
+            resolved_level = LEVELS[log_level.upcase.to_sym]
+
+            if resolved_level.nil?
+              raise(
+                Zapp::ZappError,
+                "Invalid log level '#{log_level.upcase}', must be one of [#{LEVELS.keys.join(', ')}]"
+              )
+            end
+
+            resolved_level
+          end
+        end
+      end
+
+      def log(current_level, msg, **_tags)
+        return unless level <= LEVELS[current_level.to_sym]
+
+        write("--- #{prefix} [#{current_level}] #{msg}\n")
+      end
+
+      def flush
+        writing_thread_pool.wait_for_termination(0.1)
+
+        out_io_mutex.synchronize do
+          out.flush
+        end
+      end
+
+      # @param new_out [IO]
+      def out=(new_out)
+        @out = new_out
+      end
+
+      protected
+
+      # @return [IO]
+      def out
+        @out ||= Zapp.config.logger_out_io
+      end
+
+      # @return [String]
+      def prefix = @prefix ||= Ractor.current.name
+
+      def write(msg)
+        writing_thread_pool.post do
+          out_io_mutex.synchronize do
+            out.print(msg)
+          end
+        end
+      end
+
+      # We really just use this as a queue
+      # TODO: There's probably a smarter way of doing this with less overhead,
+      # TODO: or maybe we should just actually write logs multi-threaded
+      def writing_thread_pool
+        @writing_thread_pool ||= Concurrent::ThreadPoolExecutor.new(
+          min_threads: 1,
+          max_threads: 1,
+          max_queue: 100
+        )
+      end
+
+      def out_io_mutex
+        Ractor.current[OUT_IO_MUTEX_KEY] ||= Thread::Mutex.new
+      end
+    end
+  end
+end

data/lib/zapp/logger.rb

@@ -1,63 +1,37 @@
 # frozen_string_literal: true
 
+require_relative("logger/base")
+
 module Zapp
-  # The default logger for zap
+  # The default logger for Zapp
   class Logger
-    # Base contains all the logging functionality and is included both as class and instance methods of Zap::Logger
-    # This allows logging without creating new instances,
-    # while allowing Ractors to create their own instances for thread safety
-    module Base
-      attr_writer(:level, :prefix)
-
-      LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 }.freeze
-
-      def debug(msg)
-        log("DEBUG", msg)
-      end
-
-      def info(msg)
-        log("INFO", msg)
-      end
+    include(Zapp::Logger::Base)
 
-      def warn(msg)
-        log("WARN", msg)
-      end
+    def initialize
+      yield(self) if block_given?
+    end
 
-      def error(msg)
-        log("ERROR", msg)
-      end
+    class << self
+      # The hash key in Ractor.current that stores the global Zapp::Logger instance
+      GLOBAL_INSTANCE_KEY = "ZAPP_LOGGER_INSTANCE"
 
-      def level
-        @level ||= if ENV["ZAPP_LOG_LEVEL"] != "" && !ENV["ZAPP_LOG_LEVEL"].nil?
-                     if LEVELS[ENV["ZAPP_LOG_LEVEL"]].nil?
-                       raise(
-                         Zapp::ZappError,
-                         "Invalid log level '#{ENV['ZAP_LOG_LEVEL']}', must be one of [#{LEVELS.keys.join(', ')}]"
-                       )
-                     else
-                       LEVELS[ENV["ZAP_LOG_LEVEL"]]
-                     end
-                   else
-                     LEVELS[:DEBUG]
-                   end
+      def instance
+        Ractor.current[GLOBAL_INSTANCE_KEY] ||= new
       end
 
       private
 
-      def log(current_level, msg)
-        puts("--- #{@prefix} [#{current_level}] #{msg}") if level <= LEVELS[current_level.to_sym]
+      def method_missing(symbol, *args)
+        if respond_to_missing?(symbol)
+          instance.public_send(symbol, *args)
+        else
+          super
+        end
       end
-    end
-    include(Zapp::Logger::Base)
-
-    def initialize
-      @prefix = "Zap"
-      yield(self) if block_given?
-    end
 
-    class << self
-      include(Zapp::Logger::Base)
-      @prefix = "Zap"
+      def respond_to_missing?(symbol, include_private = false)
+        instance.respond_to?(symbol) || super(symbol, include_private)
+      end
     end
   end
 end

data/lib/zapp/pipe.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Zapp
+  # Light wrapper around a Ractor for piping messages CSP style
+  module Pipe
+    def self.new
+      Ractor.new do
+        loop do
+          Ractor.yield(Ractor.receive)
+        end
+      end
+    end
+  end
+end

data/lib/zapp/server.rb

@@ -3,53 +3,75 @@
 module Zapp
   # The Zap HTTP Server, listens on a TCP connection and processes incoming requests
   class Server
-    attr_reader(:tcp_connection, :worker_pool)
+    attr_reader(:worker_pool, :socket_pipe_receiver)
 
     def initialize
-      @tcp_connection = TCPServer.new(Zapp.config.host, Zapp.config.port)
-      @worker_pool = Zapp::WorkerPool.new(app: Zapp.config.app)
+      @socket_pipe = Zapp::Pipe.new
+      @context_pipe = Zapp::Pipe.new
+
+      @socket_pipe_receiver = Zapp::SocketPipe::Receiver.new(pipe: @socket_pipe)
+
+      @worker_pool = Zapp::WorkerPool.new(socket_pipe: @socket_pipe, context_pipe: @context_pipe)
     end
 
     def run
-      parser = Puma::HttpParser.new
-
       log_start
 
       loop do
-        socket = tcp_connection.accept
-        next if socket.eof?
+        socket = socket_pipe_receiver.take
 
-        context = Zapp::HTTPContext::Context.new(socket: socket)
-
-        context.req.parse!(parser: parser)
+        next if socket.eof?
 
-        worker_pool.process(context: context)
+        parsing_thread_pool.post do
+          ctx = Zapp::HTTPContext::Context.new(socket: socket)
 
-      rescue Puma::HttpParserError => e
-        context.res.write(data: "Invalid HTTP request", status: 500, headers: {})
-        Zapp::Logger.warn("Puma parser error: #{e}")
+          worker_pool.process(context: ctx) unless ctx.client_closed? # Parsing failed
+        end
+      rescue Errno::ECONNRESET
+        next
       end
     rescue SignalException, IRB::Abort => e
       shutdown(e)
     end
 
     def shutdown(err = nil)
-      Zapp::Logger.info("Received signal #{err}") unless err.nil?
+      Zapp::Logger.info("Received signal #{err.class.name}") unless err.nil?
       Zapp::Logger.info("Gracefully shutting down workers, allowing request processing to finish")
 
       worker_pool.drain
 
       Zapp::Logger.info("Done. See you next time!")
+      Zapp::Logger.flush
     end
 
     private
 
     def log_start
-      Zapp::Logger.info("Zap version: #{Zapp::VERSION}")
+      Zapp::Logger.info(
+        "
+        ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡
+        ⚡  ███████╗ █████╗ ██████╗ ██████╗   ⚡
+        ⚡  ╚══███╔╝██╔══██╗██╔══██╗██╔══██╗  ⚡
+        ⚡    ███╔╝ ███████║██████╔╝██████╔╝  ⚡
+        ⚡   ███╔╝  ██╔══██║██╔═══╝ ██╔═══╝   ⚡
+        ⚡  ███████╗██║  ██║██║     ██║       ⚡
+        ⚡  ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝       ⚡
+        ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡
+"
+      )
+      Zapp::Logger.info("Zapp version: #{Zapp::VERSION}")
       Zapp::Logger.info("Environment: #{Zapp.config.mode}")
       Zapp::Logger.info("Serving: #{Zapp.config.env[Rack::RACK_URL_SCHEME]}://#{Zapp.config.host}:#{Zapp.config.port}")
       Zapp::Logger.info("Parallel workers: #{Zapp.config.parallelism}")
       Zapp::Logger.info("Ready to accept requests")
     end
+
+    def parsing_thread_pool
+      @parsing_thread_pool ||= Concurrent::ThreadPoolExecutor.new(
+        min_threads: Zapp.config.parallelism,
+        max_threads: Zapp.config.parallelism,
+        max_queue: Zapp.config.parallelism * 1_000
+      )
+    end
   end
 end

data/lib/zapp/socket_pipe/receiver.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Zapp
+  module SocketPipe
+    class Receiver
+      attr_reader(:pipe, :raw_tcp_pipe)
+
+      def initialize(pipe:)
+        @pipe = pipe
+        @raw_tcp_pipe = Ractor.new(Zapp.config, name: "raw-tcp-pipe") do |config|
+          server = TCPServer.new(config.host, config.port)
+
+          loop do
+            Ractor.yield(server.accept)
+          end
+        end
+      end
+
+      def take
+        Ractor.select(pipe, raw_tcp_pipe)[1]
+      end
+    end
+  end
+end

data/lib/zapp/socket_pipe/sender.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Zapp
+  module SocketPipe
+    class Sender
+      attr_reader(:pipe)
+
+      def initialize(pipe:)
+        @pipe = pipe
+      end
+
+      def push(socket)
+        pipe.send(socket)
+      end
+    end
+  end
+end

data/lib/zapp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zapp
-  VERSION = "0.1.0"
+  VERSION = "0.2.2"
 end