zapp 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '083c3deaea0cc22f0bd269afbccdd556bf66743771aca04f63f125809c934473'
-  data.tar.gz: cd3a771ca1d0e898ddaa99c71b741412e4be8370286ec484b2059317cb632802
+  metadata.gz: 6b4a4b6bdf9ac52a419e899e41344faf5ff15fdde704f70e93fe71cee334e70e
+  data.tar.gz: 4bd738d7ca1919ceef29612c5bf9a07a26ad8bda944b9adfc52197435dbb1a0a
 SHA512:
-  metadata.gz: 227f3dc9ce4c2cac931c89f2a3bca81f90f91031a78998258befb02515ee5eb1af386741646bdecc14e82649cc5cc876f360cbfb8a01bf84e119b062ab3a0eea
-  data.tar.gz: ffa29c579b1621eca0093e2c3d9a4f02975aa3be6a81aa17348aff7a7f5f54cecf4ea8aeb7829c6a821d4691c2ac9a2cd2d0be33204f2a02b1fd163b5c6990e3
+  metadata.gz: 26554e64959a88e35bf1b7f9657909da61de5a92c980550df415ae0b5564f899b25922e1fbb69d79a39a72506fe903654a007555c8e85ce3b437eb1cbbf8ccb3
+  data.tar.gz: c790f81f5fa7d1867ee6f33c3fff92f3df44ece8051e9dc3f9ed260724dd0236a3d3fd1814ba3dcf54f3743713782445a5001f54fcb275872943665055593b64

data/.rubocop.yml

@@ -5,13 +5,16 @@ AllCops:
   Exclude:
     - examples/**/*
 
+Gemspec/RequireMFA:
+  Enabled: false
+
 Style/DocumentationMethod:
   Enabled: false
 Style/MissingElse:
   Enabled: false
 Style/StringLiterals:
   EnforcedStyle: double_quotes
-Style/InlineComments:
+Style/InlineComment:
   Enabled: false
 Style/Copyright:
   Enabled: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    zapp (0.1.1)
+    zapp (0.2.1)
       concurrent-ruby (~> 1.1.9)
       puma (~> 5.5.2)
       rack (~> 2.2.3)

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/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,
 
@@ -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/request.rb

@@ -9,7 +9,7 @@ module Zapp
       attr_reader(:raw, :data, :body)
 
       # Request parsing is done threaded, but not in separate Ractors.
-      # So we allocate an HTTP parser per thread and assigns it to this hash key on Thread.current
+      # 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:)
@@ -19,7 +19,7 @@ module Zapp
 
         parser.execute(data, raw, 0)
 
-        @body = Zapp::InputStream.new(string: "parser.body")
+        @body = Zapp::InputStream.new(string: parser.body)
 
         parser.reset
       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,74 +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 = { TRACE: 0, DEBUG: 1, INFO: 2, WARN: 3, ERROR: 4 }.freeze
-
-      FROZEN_ENV = ENV.map { |k, v| [k.freeze, v.freeze] }
-                      .to_h.freeze
-
-      def trace(msg)
-        log("TRACE", msg)
-      end
-
-      def debug(msg)
-        log("DEBUG", msg)
-      end
+    include(Zapp::Logger::Base)
 
-      def info(msg)
-        log("INFO", msg)
-      end
+    def initialize
+      yield(self) if block_given?
+    end
 
-      def warn(msg)
-        log("WARN", msg)
-      end
+    class << self
+      # The hash key in Ractor.current that stores the global Zapp::Logger instance
+      GLOBAL_INSTANCE_KEY = "ZAPP_LOGGER_INSTANCE"
 
-      def error(msg)
-        log("ERROR", msg)
+      def instance
+        Ractor.current[GLOBAL_INSTANCE_KEY] ||= new
       end
 
-      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
+      private
 
-            resolved_level
-          end
+      def method_missing(symbol, *args)
+        if respond_to_missing?(symbol)
+          instance.public_send(symbol, *args)
+        else
+          super
         end
       end
 
-      def log(current_level, msg, **_tags)
-        puts("--- #{@prefix} [#{current_level}] #{msg}") if level <= LEVELS[current_level.to_sym]
+      def respond_to_missing?(symbol, include_private = false)
+        instance.respond_to?(symbol) || super(symbol, include_private)
       end
     end
-    include(Zapp::Logger::Base)
-
-    def initialize
-      yield(self) if block_given?
-    end
-
-    class << self
-      include(Zapp::Logger::Base)
-    end
   end
 end
-
-Zapp::Logger.prefix = "Zapp"

data/lib/zapp/server.rb

@@ -11,7 +11,7 @@ module Zapp
 
       @socket_pipe_receiver = Zapp::SocketPipe::Receiver.new(pipe: @socket_pipe)
 
-      @worker_pool = Zapp::WorkerPool.new(app: Zapp.config.app, socket_pipe: @socket_pipe, context_pipe: @context_pipe)
+      @worker_pool = Zapp::WorkerPool.new(socket_pipe: @socket_pipe, context_pipe: @context_pipe)
     end
 
     def run
@@ -38,16 +38,17 @@ module Zapp
       Zapp::Logger.info("Received signal #{err.class.name}") unless err.nil?
       Zapp::Logger.info("Gracefully shutting down workers, allowing request processing to finish")
 
-      socket_pipe_receiver.drain
       worker_pool.drain
 
       Zapp::Logger.info("Done. See you next time!")
+      Zapp::Logger.flush
     end
 
     private
 
     def log_start
-      Zapp::Logger.info("
+      Zapp::Logger.info(
+        "
         ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡
         ⚡  ███████╗ █████╗ ██████╗ ██████╗   ⚡
         ⚡  ╚══███╔╝██╔══██╗██╔══██╗██╔══██╗  ⚡
@@ -56,7 +57,8 @@ module Zapp
         ⚡  ███████╗██║  ██║██║     ██║       ⚡
         ⚡  ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝       ⚡
         ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡
-")
+"
+      )
       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}")

data/lib/zapp/socket_pipe/receiver.rb

@@ -19,14 +19,6 @@ module Zapp
       def take
         Ractor.select(pipe, raw_tcp_pipe)[1]
       end
-
-      def drain
-        Thread.new do
-          loop do
-            take
-          end
-        end
-      end
     end
   end
 end

data/lib/zapp/version.rb

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

data/lib/zapp/worker/request_processor.rb

@@ -4,11 +4,9 @@ module Zapp
   class Worker < Ractor
     # Processes HTTP requests
     class RequestProcessor
-      attr_reader(:app, :config, :socket_pipe_sender, :context_pipe)
+      attr_reader(:socket_pipe_sender, :context_pipe)
 
-      def initialize(context_pipe:, socket_pipe:, app:, config:)
-        @app = app
-        @config = config
+      def initialize(context_pipe:, socket_pipe:)
         @socket_pipe_sender = Zapp::SocketPipe::Sender.new(pipe: socket_pipe)
         @context_pipe = context_pipe
       end
@@ -16,26 +14,24 @@ module Zapp
       def loop
         while (context = context_pipe.take)
           if context == Zapp::WorkerPool::SIGNALS[:EXIT]
-            logger.trace("Received exit signal, shutting down")
-            thread_pool.shutdown
+            Zapp::Logger.trace("Received exit signal, shutting down")
+            shutdown
             break
           end
 
+          process = lambda {
+            process(context: context)
+          }
 
-            process = lambda {
-              process(context: context)
-            }
-
-            if config.log_requests
-              log_request_time(context: context, &process)
-            else
-              process.call
-            end
-
-            # We send sockets that the client hasn't closed yet,
-            # back to the main ractor for HTTP request parsing again
-            socket_pipe_sender.push(context.socket) unless context.client_closed?
+          if Zapp.config.log_requests
+            log_request_time(context: context, &process)
+          else
+            process.call
+          end
 
+          # We send sockets that the client hasn't closed yet,
+          # back to the main ractor for HTTP request parsing again
+          socket_pipe_sender.push(context.socket) unless context.client_closed?
         end
       end
 
@@ -43,16 +39,16 @@ module Zapp
 
       # Processes an HTTP request
       def process(context:)
-        env = prepare_env(data: context.req.data, body: context.req.body, env: config.env.dup)
+        env = prepare_env(data: context.req.data, body: context.req.body, env: Zapp.config.env.dup)
 
-        status, headers, response_body_stream = @app.call(env)
+        status, headers, response_body_stream = Zapp.config.app.call(env)
 
         response_body = body_stream_to_string(response_body_stream)
 
         context.res.write(data: response_body, status: status, headers: headers)
       rescue StandardError => e
         context.res.write(data: "An unexpected error occurred", status: 500, headers: {})
-        logger.error("#{e}\n\n#{e.backtrace&.join(",\n")}") if config.log_uncaught_errors
+        Zapp::Logger.error("#{e}\n\n#{e.backtrace&.join(",\n")}") if Zapp.config.log_uncaught_errors
       end
 
       # Merges HTTP data and body into the env to be passed to the rack app
@@ -79,7 +75,7 @@ module Zapp
         path = context.req.data["PATH_INFO"]
         status = context.res.status
 
-        logger.info(
+        Zapp::Logger.info(
           "#{method} #{path} - Completed in #{request_time}ms with status #{status}"
         )
       end
@@ -96,19 +92,18 @@ module Zapp
         response_body
       end
 
+      def shutdown
+        Zapp::Logger.flush
+        thread_pool.shutdown
+      end
+
       def thread_pool
         @thread_pool ||= Concurrent::ThreadPoolExecutor.new(
-          min_threads: config.threads_per_worker,
-          max_threads: config.threads_per_worker,
-          max_queue: 1000,
+          min_threads: Zapp.config.threads_per_worker,
+          max_threads: Zapp.config.threads_per_worker,
+          max_queue: 1000
         )
       end
-
-      def logger
-        @logger ||= config.logger_class.new do |l|
-          l.prefix = Ractor.current.name
-        end
-      end
     end
   end
 end

data/lib/zapp/worker.rb

@@ -6,19 +6,18 @@ module Zapp
   # One worker processing requests in parallel
   class Worker < Ractor
     class << self
-      def new(context_pipe:, socket_pipe:, app:, index:)
+      def new(context_pipe:, socket_pipe:, index:)
         super(
           context_pipe,
           socket_pipe,
-          app,
           Zapp.config.dup,
           name: name(index)
-        ) do |context_pipe, socket_pipe, app, config|
+        ) do |context_pipe, socket_pipe, config|
+          Ractor.current[Zapp::RACTOR_CONFIG_KEY] = config
+
           processor = Zapp::Worker::RequestProcessor.new(
             socket_pipe: socket_pipe,
-            context_pipe: context_pipe,
-            app: app,
-            config: config
+            context_pipe: context_pipe
           )
 
           processor.loop

data/lib/zapp/worker_pool.rb

@@ -9,14 +9,13 @@ module Zapp
       EXIT: :exit
     }.freeze
 
-    def initialize(app:, context_pipe:, socket_pipe:)
+    def initialize(context_pipe:, socket_pipe:)
       @context_pipe = context_pipe
       @workers = []
       Zapp.config.parallelism.times do |i|
         @workers << Worker.new(
           context_pipe: context_pipe,
           socket_pipe: socket_pipe,
-          app: app,
           index: i
         )
       end
@@ -30,9 +29,11 @@ module Zapp
     # Finishes processing of all requests and shuts down workers
     def drain
       Zapp.config.parallelism.times { process(context: SIGNALS[:EXIT]) }
-      workers.map(&:terminate)
-    rescue Ractor::ClosedError
-      # Ractor has already exited
+      workers.map do |w|
+        w.terminate
+      rescue Ractor::ClosedError
+        # Ractor has already exited
+      end
     end
   end
 end

data/lib/zapp.rb

@@ -11,11 +11,14 @@ require("rack")
 module Zapp
   class ZappError < StandardError; end
 
+  # The hash key in Ractor.current that stores the global Zapp::Configuration instance
+  RACTOR_CONFIG_KEY = "ZAPP_CONFIG"
+
   class << self
     def config(reset: false)
-      @config = Zapp::Configuration.new if reset
+      Ractor.current[RACTOR_CONFIG_KEY] = Zapp::Configuration.new if reset
 
-      @config ||= Zapp::Configuration.new
+      Ractor.current[RACTOR_CONFIG_KEY] ||= Zapp::Configuration.new
     end
 
     def configure