puma 4.3.12 → 5.6.9

data/lib/puma/error_logger.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'puma/const'
+
+module Puma
+  # The implementation of a detailed error logging.
+  # @version 5.0.0
+  #
+  class ErrorLogger
+    include Const
+
+    attr_reader :ioerr
+
+    REQUEST_FORMAT = %{"%s %s%s" - (%s)}
+
+    def initialize(ioerr)
+      @ioerr = ioerr
+
+      @debug = ENV.key? 'PUMA_DEBUG'
+    end
+
+    def self.stdio
+      new $stderr
+    end
+
+    # Print occurred error details.
+    # +options+ hash with additional options:
+    # - +error+ is an exception object
+    # - +req+ the http request
+    # - +text+ (default nil) custom string to print in title
+    #   and before all remaining info.
+    #
+    def info(options={})
+      log title(options)
+    end
+
+    # Print occurred error details only if
+    # environment variable PUMA_DEBUG is defined.
+    # +options+ hash with additional options:
+    # - +error+ is an exception object
+    # - +req+ the http request
+    # - +text+ (default nil) custom string to print in title
+    #   and before all remaining info.
+    #
+    def debug(options={})
+      return unless @debug
+
+      error = options[:error]
+      req = options[:req]
+
+      string_block = []
+      string_block << title(options)
+      string_block << request_dump(req) if request_parsed?(req)
+      string_block << error.backtrace if error
+
+      log string_block.join("\n")
+    end
+
+    def title(options={})
+      text = options[:text]
+      req = options[:req]
+      error = options[:error]
+
+      string_block = ["#{Time.now}"]
+      string_block << " #{text}" if text
+      string_block << " (#{request_title(req)})" if request_parsed?(req)
+      string_block << ": #{error.inspect}" if error
+      string_block.join('')
+    end
+
+    def request_dump(req)
+      "Headers: #{request_headers(req)}\n" \
+      "Body: #{req.body}"
+    end
+
+    def request_title(req)
+      env = req.env
+
+      REQUEST_FORMAT % [
+        env[REQUEST_METHOD],
+        env[REQUEST_PATH] || env[PATH_INFO],
+        env[QUERY_STRING] || "",
+        env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR] || "-"
+      ]
+    end
+
+    def request_headers(req)
+      headers = req.env.select { |key, _| key.start_with?('HTTP_') }
+      headers.map { |key, value| [key[5..-1], value] }.to_h.inspect
+    end
+
+    def request_parsed?(req)
+      req && req.env[REQUEST_METHOD]
+    end
+
+    private
+
+    def log(str)
+      ioerr.puts str
+
+      ioerr.flush unless ioerr.sync
+    end
+  end
+end

data/lib/puma/events.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'puma/const'
 require "puma/null_io"
+require 'puma/error_logger'
 require 'stringio'
 
 module Puma
@@ -23,8 +23,6 @@ module Puma
       end
     end
 
-    include Const
-
     # Create an Events object that prints to +stdout+ and +stderr+.
     #
     def initialize(stdout, stderr)
@@ -32,10 +30,8 @@ module Puma
       @stdout = stdout
       @stderr = stderr
 
-      @stdout.sync = true
-      @stderr.sync = true
-
       @debug = ENV.key? 'PUMA_DEBUG'
+      @error_logger = ErrorLogger.new(@stderr)
 
       @hooks = Hash.new { |h,k| h[k] = [] }
     end
@@ -66,7 +62,10 @@ module Puma
     # Write +str+ to +@stdout+
     #
     def log(str)
-      @stdout.puts format(str)
+      @stdout.puts format(str) if @stdout.respond_to? :puts
+
+      @stdout.flush unless @stdout.sync
+    rescue Errno::EPIPE
     end
 
     def write(str)
@@ -80,7 +79,7 @@ module Puma
     # Write +str+ to +@stderr+
     #
     def error(str)
-      @stderr.puts format("ERROR: #{str}")
+      @error_logger.info(text: format("ERROR: #{str}"))
       exit 1
     end
 
@@ -88,53 +87,75 @@ module Puma
       formatter.call(str)
     end
 
+    # An HTTP connection error has occurred.
+    # +error+ a connection exception, +req+ the request,
+    # and +text+ additional info
+    # @version 5.0.0
+    #
+    def connection_error(error, req, text="HTTP connection error")
+      @error_logger.info(error: error, req: req, text: text)
+    end
+
     # An HTTP parse error has occurred.
-    # +server+ is the Server object, +env+ the request, and +error+ a
-    # parsing exception.
+    # +error+ a parsing exception,
+    # and +req+ the request.
     #
-    def parse_error(server, env, error)
-      @stderr.puts "#{Time.now}: HTTP parse error, malformed request " \
-        "(#{env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR]}#{env[REQUEST_PATH]}): " \
-        "#{error.inspect}" \
-        "\n---\n"
+    def parse_error(error, req)
+      @error_logger.info(error: error, req: req, text: 'HTTP parse error, malformed request')
     end
 
     # An SSL error has occurred.
-    # +server+ is the Server object, +peeraddr+ peer address, +peercert+
-    # any peer certificate (if present), and +error+ an exception object.
+    # @param error <Puma::MiniSSL::SSLError>
+    # @param ssl_socket <Puma::MiniSSL::Socket>
     #
-    def ssl_error(server, peeraddr, peercert, error)
+    def ssl_error(error, ssl_socket)
+      peeraddr = ssl_socket.peeraddr.last rescue "<unknown>"
+      peercert = ssl_socket.peercert
       subject = peercert ? peercert.subject : nil
-      @stderr.puts "#{Time.now}: SSL error, peer: #{peeraddr}, peer cert: #{subject}, #{error.inspect}"
+      @error_logger.info(error: error, text: "SSL error, peer: #{peeraddr}, peer cert: #{subject}")
     end
 
     # An unknown error has occurred.
-    # +server+ is the Server object, +error+ an exception object,
-    # +kind+ some additional info, and +env+ the request.
+    # +error+ an exception object, +req+ the request,
+    # and +text+ additional info
     #
-    def unknown_error(server, error, kind="Unknown", env=nil)
-      if error.respond_to? :render
-        error.render "#{Time.now}: #{kind} error", @stderr
-      else
-        if env
-          string_block = [ "#{Time.now}: #{kind} error handling request { #{env['REQUEST_METHOD']} #{env['PATH_INFO']} }" ]
-          string_block << error.inspect
-        else
-          string_block = [ "#{Time.now}: #{kind} error: #{error.inspect}" ]
-        end
-        string_block << error.backtrace
-        @stderr.puts string_block.join("\n")
-      end
+    def unknown_error(error, req=nil, text="Unknown error")
+      @error_logger.info(error: error, req: req, text: text)
+    end
+
+    # Log occurred error debug dump.
+    # +error+ an exception object, +req+ the request,
+    # and +text+ additional info
+    # @version 5.0.0
+    #
+    def debug_error(error, req=nil, text="")
+      @error_logger.debug(error: error, req: req, text: text)
     end
 
     def on_booted(&block)
       register(:on_booted, &block)
     end
 
+    def on_restart(&block)
+      register(:on_restart, &block)
+    end
+
+    def on_stopped(&block)
+      register(:on_stopped, &block)
+    end
+
     def fire_on_booted!
       fire(:on_booted)
     end
 
+    def fire_on_restart!
+      fire(:on_restart)
+    end
+
+    def fire_on_stopped!
+      fire(:on_stopped)
+    end
+
     DEFAULT = new(STDOUT, STDERR)
 
     # Returns an Events object which writes its status to 2 StringIO

data/lib/puma/io_buffer.rb

@@ -1,4 +1,11 @@
 # frozen_string_literal: true
 
-require 'puma/detect'
-require 'puma/puma_http11'
+module Puma
+  class IOBuffer < String
+    def append(*args)
+      args.each { |a| concat(a) }
+    end
+
+    alias reset clear
+  end
+end

data/lib/puma/jruby_restart.rb

@@ -22,63 +22,5 @@ module Puma
       execlp(cmd, *argv)
       raise SystemCallError.new(FFI.errno)
     end
-
-    PermKey = 'PUMA_DAEMON_PERM'
-    RestartKey = 'PUMA_DAEMON_RESTART'
-
-    # Called to tell things "Your now always in daemon mode,
-    # don't try to reenter it."
-    #
-    def self.perm_daemonize
-      ENV[PermKey] = "1"
-    end
-
-    def self.daemon?
-      ENV.key?(PermKey) || ENV.key?(RestartKey)
-    end
-
-    def self.daemon_init
-      return true if ENV.key?(PermKey)
-
-      return false unless ENV.key? RestartKey
-
-      master = ENV[RestartKey]
-
-      # In case the master disappears early
-      begin
-        Process.kill "SIGUSR2", master.to_i
-      rescue SystemCallError => e
-      end
-
-      ENV[RestartKey] = ""
-
-      setsid
-
-      null = File.open "/dev/null", "w+"
-      STDIN.reopen null
-      STDOUT.reopen null
-      STDERR.reopen null
-
-      true
-    end
-
-    def self.daemon_start(dir, argv)
-      ENV[RestartKey] = Process.pid.to_s
-
-      if k = ENV['PUMA_JRUBY_DAEMON_OPTS']
-        ENV['JRUBY_OPTS'] = k
-      end
-
-      cmd = argv.first
-      argv = ([:string] * argv.size).zip(argv).flatten
-      argv << :string
-      argv << nil
-
-      chdir(dir)
-      ret = fork
-      return ret if ret != 0
-      execlp(cmd, *argv)
-      raise SystemCallError.new(FFI.errno)
-    end
   end
 end

data/lib/puma/json_serialization.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+require 'stringio'
+
+module Puma
+
+  # Puma deliberately avoids the use of the json gem and instead performs JSON
+  # serialization without any external dependencies. In a puma cluster, loading
+  # any gem into the puma master process means that operators cannot use a
+  # phased restart to upgrade their application if the new version of that
+  # application uses a different version of that gem. The json gem in
+  # particular is additionally problematic because it leverages native
+  # extensions. If the puma master process relies on a gem with native
+  # extensions and operators remove gems from disk related to old releases,
+  # subsequent phased restarts can fail.
+  #
+  # The implementation of JSON serialization in this module is not designed to
+  # be particularly full-featured or fast. It just has to handle the few places
+  # where Puma relies on JSON serialization internally.
+
+  module JSONSerialization
+    QUOTE = /"/
+    BACKSLASH = /\\/
+    CONTROL_CHAR_TO_ESCAPE = /[\x00-\x1F]/ # As required by ECMA-404
+    CHAR_TO_ESCAPE = Regexp.union QUOTE, BACKSLASH, CONTROL_CHAR_TO_ESCAPE
+
+    class SerializationError < StandardError; end
+
+    class << self
+      def generate(value)
+        StringIO.open do |io|
+          serialize_value io, value
+          io.string
+        end
+      end
+
+      private
+
+      def serialize_value(output, value)
+        case value
+        when Hash
+          output << '{'
+          value.each_with_index do |(k, v), index|
+            output << ',' if index != 0
+            serialize_object_key output, k
+            output << ':'
+            serialize_value output, v
+          end
+          output << '}'
+        when Array
+          output << '['
+          value.each_with_index do |member, index|
+            output << ',' if index != 0
+            serialize_value output, member
+          end
+          output << ']'
+        when Integer, Float
+          output << value.to_s
+        when String
+          serialize_string output, value
+        when true
+          output << 'true'
+        when false
+          output << 'false'
+        when nil
+          output << 'null'
+        else
+          raise SerializationError, "Unexpected value of type #{value.class}"
+        end
+      end
+
+      def serialize_string(output, value)
+        output << '"'
+        output << value.gsub(CHAR_TO_ESCAPE) do |character|
+          case character
+          when BACKSLASH
+            '\\\\'
+          when QUOTE
+            '\\"'
+          when CONTROL_CHAR_TO_ESCAPE
+            '\u%.4X' % character.ord
+          end
+        end
+        output << '"'
+      end
+
+      def serialize_object_key(output, value)
+        case value
+        when Symbol, String
+          serialize_string output, value.to_s
+        else
+          raise SerializationError, "Could not serialize object of type #{value.class} as object key"
+        end
+      end
+    end
+  end
+end