puma 3.11.1 → 6.6.0

data/lib/puma/commonlogger.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Puma
   # Rack::CommonLogger forwards every request to the given +app+, and
   # logs a line in the
-  # {Apache common log format}[http://httpd.apache.org/docs/1.3/logs.html#common]
+  # {Apache common log format}[https://httpd.apache.org/docs/2.4/logs.html#common]
   # to the +logger+.
   #
   # If +logger+ is nil, CommonLogger will fall back +rack.errors+, which is
@@ -14,7 +16,7 @@ module Puma
   # (which is called without arguments in order to make the error appear for
   # sure)
   class CommonLogger
-    # Common Log Format: http://httpd.apache.org/docs/1.3/logs.html#common
+    # Common Log Format: https://httpd.apache.org/docs/2.4/logs.html#common
     #
     #   lilith.local - - [07/Aug/2006 23:58:02 -0400] "GET / HTTP/1.1" 500 -
     #
@@ -23,10 +25,17 @@ module Puma
 
     HIJACK_FORMAT = %{%s - %s [%s] "%s %s%s %s" HIJACKED -1 %0.4f\n}
 
-    CONTENT_LENGTH = 'Content-Length'.freeze
-    PATH_INFO      = 'PATH_INFO'.freeze
-    QUERY_STRING   = 'QUERY_STRING'.freeze
-    REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+    LOG_TIME_FORMAT = '%d/%b/%Y:%H:%M:%S %z'
+
+    CONTENT_LENGTH       = 'Content-Length' # should be lower case from app,
+                                            # Util::HeaderHash allows mixed
+    HTTP_VERSION         = Const::HTTP_VERSION
+    HTTP_X_FORWARDED_FOR = Const::HTTP_X_FORWARDED_FOR
+    PATH_INFO            = Const::PATH_INFO
+    QUERY_STRING         = Const::QUERY_STRING
+    REMOTE_ADDR          = Const::REMOTE_ADDR
+    REMOTE_USER          = 'REMOTE_USER'
+    REQUEST_METHOD       = Const::REQUEST_METHOD
 
     def initialize(app, logger=nil)
       @app = app
@@ -55,13 +64,13 @@ module Puma
       now = Time.now
 
       msg = HIJACK_FORMAT % [
-        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
-        env["REMOTE_USER"] || "-",
-        now.strftime("%d/%b/%Y %H:%M:%S"),
+        env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR] || "-",
+        env[REMOTE_USER] || "-",
+        now.strftime(LOG_TIME_FORMAT),
         env[REQUEST_METHOD],
         env[PATH_INFO],
         env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
-        env["HTTP_VERSION"],
+        env[HTTP_VERSION],
         now - began_at ]
 
       write(msg)
@@ -72,13 +81,13 @@ module Puma
       length = extract_content_length(header)
 
       msg = FORMAT % [
-        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
-        env["REMOTE_USER"] || "-",
-        now.strftime("%d/%b/%Y:%H:%M:%S %z"),
+        env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR] || "-",
+        env[REMOTE_USER] || "-",
+        now.strftime(LOG_TIME_FORMAT),
         env[REQUEST_METHOD],
         env[PATH_INFO],
         env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
-        env["HTTP_VERSION"],
+        env[HTTP_VERSION],
         status.to_s[0..3],
         length,
         now - began_at ]

data/lib/puma/configuration.rb

@@ -1,24 +1,16 @@
-require 'puma/rack/builder'
-require 'puma/plugin'
-require 'puma/const'
+# frozen_string_literal: true
 
-module Puma
-
-  module ConfigDefault
-    DefaultRackup = "config.ru"
-
-    DefaultTCPHost = "0.0.0.0"
-    DefaultTCPPort = 9292
-    DefaultWorkerTimeout = 60
-    DefaultWorkerShutdownTimeout = 30
-  end
+require_relative 'plugin'
+require_relative 'const'
+require_relative 'dsl'
 
+module Puma
   # A class used for storing "leveled" configuration options.
   #
   # In this class any "user" specified options take precedence over any
   # "file" specified options, take precedence over any "default" options.
   #
-  # User input is prefered over "defaults":
+  # User input is preferred over "defaults":
   #   user_options    = { foo: "bar" }
   #   default_options = { foo: "zoo" }
   #   options = UserFileDefaultOptions.new(user_options, default_options)
@@ -30,7 +22,7 @@ module Puma
   #   puts options.all_of(:foo)
   #   # => ["bar", "zoo"]
   #
-  # A "file" option can be set. This config will be prefered over "default" options
+  # A "file" option can be set. This config will be preferred over "default" options
   # but will defer to any available "user" specified options.
   #
   #   user_options    = { foo: "bar" }
@@ -52,9 +44,7 @@ module Puma
     attr_reader :user_options, :file_options, :default_options
 
     def [](key)
-      return user_options[key]    if user_options.key?(key)
-      return file_options[key]    if file_options.key?(key)
-      return default_options[key] if default_options.key?(key)
+      fetch(key)
     end
 
     def []=(key, value)
@@ -62,7 +52,11 @@ module Puma
     end
 
     def fetch(key, default_value = nil)
-      self[key] || default_value
+      return user_options[key]    if user_options.key?(key)
+      return file_options[key]    if file_options.key?(key)
+      return default_options[key] if default_options.key?(key)
+
+      default_value
     end
 
     def all_of(key)
@@ -88,6 +82,12 @@ module Puma
         end
       end
     end
+
+    def final_options
+      default_options
+        .merge(file_options)
+        .merge(user_options)
+    end
   end
 
   # The main configuration class of Puma.
@@ -104,16 +104,17 @@ module Puma
   #
   # It also handles loading plugins.
   #
-  # > Note: `:port` and `:host` are not valid keys. By they time they make it to the
+  # [Note:]
+  #   `:port` and `:host` are not valid keys. By the time they make it to the
   #   configuration options they are expected to be incorporated into a `:binds` key.
   #   Under the hood the DSL maps `port` and `host` calls to `:binds`
   #
-  #   config = Configuration.new({}) do |user_config, file_config, default_config|
-  #     user_config.port 3003
-  #   end
-  #   config.load
-  #   puts config.options[:port]
-  #   # => 3003
+  #     config = Configuration.new({}) do |user_config, file_config, default_config|
+  #       user_config.port 3003
+  #     end
+  #     config.load
+  #     puts config.options[:port]
+  #     # => 3003
   #
   # It is expected that `load` is called on the configuration instance after setting
   # config. This method expands any values in `config_file` and puts them into the
@@ -124,10 +125,56 @@ module Puma
   # is done because an environment variable may have been modified while loading
   # configuration files.
   class Configuration
-    include ConfigDefault
-
-    def initialize(user_options={}, default_options = {}, &block)
-      default_options = self.puma_default_options.merge(default_options)
+    DEFAULTS = {
+      auto_trim_time: 30,
+      binds: ['tcp://0.0.0.0:9292'.freeze],
+      clean_thread_locals: false,
+      debug: false,
+      enable_keep_alives: true,
+      early_hints: nil,
+      environment: 'development'.freeze,
+      # Number of seconds to wait until we get the first data for the request.
+      first_data_timeout: 30,
+      # Number of seconds to wait until the next request before shutting down.
+      idle_timeout: nil,
+      io_selector_backend: :auto,
+      log_requests: false,
+      logger: STDOUT,
+      # How many requests to attempt inline before sending a client back to
+      # the reactor to be subject to normal ordering. The idea here is that
+      # we amortize the cost of going back to the reactor for a well behaved
+      # but very "greedy" client across 10 requests. This prevents a not
+      # well behaved client from monopolizing the thread forever.
+      max_fast_inline: 10,
+      max_threads: Puma.mri? ? 5 : 16,
+      min_threads: 0,
+      mode: :http,
+      mutate_stdout_and_stderr_to_sync_on_write: true,
+      out_of_band: [],
+      # Number of seconds for another request within a persistent session.
+      persistent_timeout: 20,
+      queue_requests: true,
+      rackup: 'config.ru'.freeze,
+      raise_exception_on_sigterm: true,
+      reaping_time: 1,
+      remote_address: :socket,
+      silence_single_worker_warning: false,
+      silence_fork_callback_warning: false,
+      tag: File.basename(Dir.getwd),
+      tcp_host: '0.0.0.0'.freeze,
+      tcp_port: 9292,
+      wait_for_less_busy_worker: 0.005,
+      worker_boot_timeout: 60,
+      worker_check_interval: 5,
+      worker_culling_strategy: :youngest,
+      worker_shutdown_timeout: 30,
+      worker_timeout: 60,
+      workers: 0,
+      http_content_length_limit: nil
+    }
+
+    def initialize(user_options={}, default_options = {}, env = ENV, &block)
+      default_options = self.puma_default_options(env).merge(default_options)
 
       @options     = UserFileDefaultOptions.new(user_options, default_options)
       @plugins     = PluginLoader.new
@@ -135,6 +182,12 @@ module Puma
       @file_dsl    = DSL.new(@options.file_options, self)
       @default_dsl = DSL.new(@options.default_options, self)
 
+      if !@options[:prune_bundler]
+        default_options[:preload_app] = (@options[:workers] > 1) && Puma.forkable?
+      end
+
+      @puma_bundler_pruned = env.key? 'PUMA_BUNDLER_PRUNED'
+
       if block
         configure(&block)
       end
@@ -165,26 +218,27 @@ module Puma
       self
     end
 
-    def puma_default_options
+    def puma_default_options(env = ENV)
+      defaults = DEFAULTS.dup
+      puma_options_from_env(env).each { |k,v| defaults[k] = v if v }
+      defaults
+    end
+
+    def puma_options_from_env(env = ENV)
+      min = env['PUMA_MIN_THREADS'] || env['MIN_THREADS']
+      max = env['PUMA_MAX_THREADS'] || env['MAX_THREADS']
+      workers = if env['WEB_CONCURRENCY'] == 'auto'
+        require_processor_counter
+        ::Concurrent.available_processor_count
+      else
+        env['WEB_CONCURRENCY']
+      end
+
       {
-        :min_threads => 0,
-        :max_threads => 16,
-        :log_requests => false,
-        :debug => false,
-        :binds => ["tcp://#{DefaultTCPHost}:#{DefaultTCPPort}"],
-        :workers => 0,
-        :daemon => false,
-        :mode => :http,
-        :worker_timeout => DefaultWorkerTimeout,
-        :worker_boot_timeout => DefaultWorkerTimeout,
-        :worker_shutdown_timeout => DefaultWorkerShutdownTimeout,
-        :remote_address => :socket,
-        :tag => method(:infer_tag),
-        :environment => -> { ENV['RACK_ENV'] || "development" },
-        :rackup => DefaultRackup,
-        :logger => STDOUT,
-        :persistent_timeout => Const::PERSISTENT_TIMEOUT,
-        :first_data_timeout => Const::FIRST_DATA_TIMEOUT
+        min_threads: min && min != "" && Integer(min),
+        max_threads: max && max != "" && Integer(max),
+        workers: workers && workers != "" && Integer(workers),
+        environment: env['APP_ENV'] || env['RACK_ENV'] || env['RAILS_ENV'],
       }
     end
 
@@ -200,7 +254,7 @@ module Puma
       return [] if files == ['-']
       return files if files.any?
 
-      first_default_file = %W(config/puma/#{environment_str}.rb config/puma.rb).find do |f|
+      first_default_file = %W(config/puma/#{@options[:environment]}.rb config/puma.rb).find do |f|
         File.exist?(f)
       end
 
@@ -242,16 +296,8 @@ module Puma
     def app
       found = options[:app] || load_rackup
 
-      if @options[:mode] == :tcp
-        require 'puma/tcp_logger'
-
-        logger = @options[:logger]
-        quiet = !@options[:log_requests]
-        return TCPLogger.new(logger, found, quiet)
-      end
-
       if @options[:log_requests]
-        require 'puma/commonlogger'
+        require_relative 'commonlogger'
         logger = @options[:logger]
         found = CommonLogger.new(found, logger)
       end
@@ -264,16 +310,33 @@ module Puma
       @options[:environment]
     end
 
-    def environment_str
-      environment.respond_to?(:call) ? environment.call : environment
-    end
-
     def load_plugin(name)
       @plugins.create name
     end
 
-    def run_hooks(key, arg)
-      @options.all_of(key).each { |b| b.call arg }
+    # @param key [:Symbol] hook to run
+    # @param arg [Launcher, Int] `:on_restart` passes Launcher
+    #
+    def run_hooks(key, arg, log_writer, hook_data = nil)
+      log_writer.debug "Running #{key} hooks"
+
+      @options.all_of(key).each do |b|
+        begin
+          if Array === b
+            hook_data[b[1]] ||= Hash.new
+            b[0].call arg, hook_data[b[1]]
+          else
+            b.call arg
+          end
+        rescue => e
+          log_writer.log "WARNING hook #{key} failed with exception (#{e.class}) #{e.message}"
+          log_writer.debug e.backtrace.join("\n")
+        end
+      end
+    end
+
+    def final_options
+      @options.final_options
     end
 
     def self.temp_path
@@ -285,8 +348,14 @@ module Puma
 
     private
 
-    def infer_tag
-      File.basename(Dir.getwd)
+    def require_processor_counter
+      require 'concurrent/utility/processor_counter'
+    rescue LoadError
+      warn <<~MESSAGE
+        WEB_CONCURRENCY=auto requires the "concurrent-ruby" gem to be installed.
+        Please add "concurrent-ruby" to your Gemfile.
+      MESSAGE
+      raise
     end
 
     # Load and use the normal Rack builder if we can, otherwise
@@ -294,7 +363,7 @@ module Puma
     def rack_builder
       # Load bundler now if we can so that we can pickup rack from
       # a Gemfile
-      if ENV.key? 'PUMA_BUNDLER_PRUNED'
+      if @puma_bundler_pruned
         begin
           require 'bundler/setup'
         rescue LoadError
@@ -304,11 +373,10 @@ module Puma
       begin
         require 'rack'
         require 'rack/builder'
+        ::Rack::Builder
       rescue LoadError
-        # ok, use builtin version
-        return Puma::Rack::Builder
-      else
-        return ::Rack::Builder
+        require_relative 'rack/builder'
+        Puma::Rack::Builder
       end
     end
 
@@ -316,6 +384,8 @@ module Puma
       raise "Missing rackup file '#{rackup}'" unless File.exist?(rackup)
 
       rack_app, rack_options = rack_builder.parse_file(rackup)
+      rack_options = rack_options || {}
+
       @options.file_options.merge!(rack_options)
 
       config_ru_binds = []
@@ -329,31 +399,9 @@ module Puma
     end
 
     def self.random_token
-      begin
-        require 'openssl'
-      rescue LoadError
-      end
-
-      count = 16
-
-      bytes = nil
+      require 'securerandom' unless defined?(SecureRandom)
 
-      if defined? OpenSSL::Random
-        bytes = OpenSSL::Random.random_bytes(count)
-      elsif File.exist?("/dev/urandom")
-        File.open('/dev/urandom') { |f| bytes = f.read(count) }
-      end
-
-      if bytes
-        token = "".dup
-        bytes.each_byte { |b| token << b.to_s(16) }
-      else
-        token = (0..count).to_a.map { rand(255).to_s(16) }.join
-      end
-
-      return token
+      SecureRandom.hex(16)
     end
   end
 end
-
-require 'puma/dsl'