unicorn 3.6.1 → 3.6.2

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v3.6.1.GIT
+DEF_VER=v3.6.2.GIT
 
 LF='
 '

data/TUNING

@@ -1,12 +1,34 @@
-= Tuning Unicorn
+= Tuning \Unicorn
 
-Unicorn performance is generally as good as a (mostly) Ruby web server
+\Unicorn performance is generally as good as a (mostly) Ruby web server
 can provide.  Most often the performance bottleneck is in the web
 application running on Unicorn rather than Unicorn itself.
 
-== Unicorn Configuration
+== \Unicorn Configuration
 
 See Unicorn::Configurator for details on the config file format.
++worker_processes+ is the most-commonly needed tuning parameter.
+
+=== Unicorn::Configurator#worker_processes
+
+* worker_processes should be scaled to the number of processes your
+  backend system(s) can support.  DO NOT scale it to the number of
+  external network clients your application expects to be serving.
+  \Unicorn is NOT for serving slow clients, that is the job of nginx.
+
+* worker_processes should be *at* *least* the number of CPU cores on
+  a dedicated server.  If your application has occasionally slow
+  responses that are /not/ CPU-intensive, you may increase this to
+  workaround those inefficiencies.
+
+* worker_processes may be increased for Unicorn::OobGC users to provide
+  more consistent response times.
+
+* Never, ever, increase worker_processes to the point where the system
+  runs out of physical memory and hits swap.  Production servers should
+  never see heavy swap activity.
+
+=== Unicorn::Configurator#listen Options
 
 * Setting a very low value for the :backlog parameter in "listen"
   directives can allow failover to happen more quickly if your
@@ -30,6 +52,11 @@ See Unicorn::Configurator for details on the config file format.
   and may also thrash CPU caches, cancelling out performance gains
   one would normally expect.
 
+* UNIX domain sockets are slighly faster than TCP sockets, but only
+  work if nginx is on the same machine.
+
+== Other \Unicorn settings
+
 * Setting "preload_app true" can allow copy-on-write-friendly GC to
   be used to save memory.  It will probably not work out of the box with
   applications that open sockets or perform random I/O on files.
@@ -40,12 +67,7 @@ See Unicorn::Configurator for details on the config file format.
 * On POSIX-compliant filesystems, it is safe for multiple threads or
   processes to append to one log file as long as all the processes are
   have them unbuffered (File#sync = true) or they are
-  record(line)-buffered in userspace.
-
-* worker_processes should be scaled to the number of processes your
-  backend system(s) can support.  DO NOT scale it to the number of
-  external network clients your application expects to be serving.
-  Unicorn is NOT for serving slow clients, that is the job of nginx.
+  record(line)-buffered in userspace before any writes.
 
 == Kernel Parameters (Linux sysctl)
 

data/examples/big_app_gc.rb

@@ -1,33 +1,2 @@
-# Run GC after every request, before attempting to accept more connections.
-#
-# You could customize this patch to read REQ["PATH_INFO"] and only
-# call GC.start after expensive requests.
-#
-# We could have this wrap the response body.close as middleware, but the
-# scannable stack is would still be bigger than it would be here.
-#
-# This shouldn't hurt overall performance as long as the server cluster
-# is at <=50% CPU capacity, and improves the performance of most memory
-# intensive requests.  This serves to improve _client-visible_
-# performance (possibly at the cost of overall performance).
-#
-# We'll call GC after each request is been written out to the socket, so
-# the client never sees the extra GC hit it. It's ideal to call the GC
-# inside the HTTP server (vs middleware or hooks) since the stack is
-# smaller at this point, so the GC will both be faster and more
-# effective at releasing unused memory.
-#
-# This monkey patch is _only_ effective for applications that use a lot
-# of memory, and will hurt simpler apps/endpoints that can process
-# multiple requests before incurring GC.
-
-class Unicorn::HttpServer
-  REQ = Unicorn::HttpRequest::REQ
-  alias _process_client process_client
-  undef_method :process_client
-  def process_client(client)
-    _process_client(client)
-    REQ.clear
-    GC.start
-  end
-end if defined?(Unicorn)
+# see {Unicorn::OobGC}[http://unicorn.bogomips.org/Unicorn/OobGC.html]
+# Unicorn::OobGC was broken in Unicorn v3.3.1 - v3.6.1 and fixed in v3.6.2

data/examples/nginx.conf

@@ -125,10 +125,15 @@ http {
       proxy_redirect off;
 
       # set "proxy_buffering off" *only* for Rainbows! when doing
-      # Comet/long-poll stuff.  It's also safe to set if you're
-      # using only serving fast clients with Unicorn + nginx.
-      # Otherwise you _want_ nginx to buffer responses to slow
-      # clients, really.
+      # Comet/long-poll/streaming.  It's also safe to set if you're using
+      # only serving fast clients with Unicorn + nginx, but not slow
+      # clients.  You normally want nginx to buffer responses to slow
+      # clients, even with Rails 3.1 streaming because otherwise a slow
+      # client can become a bottleneck of Unicorn.
+      #
+      # The Rack application may also set "X-Accel-Buffering (yes|no)"
+      # in the response headers do disable/enable buffering on a
+      # per-response basis.
       # proxy_buffering off;
 
       proxy_pass http://app_server;

data/lib/unicorn/configurator.rb

@@ -8,6 +8,8 @@ require 'logger'
 # example configuration files.  An example config file for use with
 # nginx is also available at
 # http://unicorn.bogomips.org/examples/nginx.conf
+#
+# See the link:/TUNING.html document for more information on tuning unicorn.
 class Unicorn::Configurator
   include Unicorn
 
@@ -253,24 +255,32 @@ class Unicorn::Configurator
   #
   # [:tcp_nodelay => true or false]
   #
-  #   Disables Nagle's algorithm on TCP sockets if +true+
+  #   Disables Nagle's algorithm on TCP sockets if +true+.
+  #
+  #   Setting this to +true+ can make streaming responses in Rails 3.1
+  #   appear more quickly at the cost of slightly higher bandwidth usage.
+  #   The effect of this option is most visible if nginx is not used,
+  #   but nginx remains highly recommended with \Unicorn.
   #
   #   This has no effect on UNIX sockets.
   #
-  #   Default: operating system defaults (usually Nagle's algorithm enabled)
+  #   Default: +false+ (Nagle's algorithm enabled) in \Unicorn,
+  #   +true+ in Rainbows!
   #
   # [:tcp_nopush => true or false]
   #
   #   Enables/disables TCP_CORK in Linux or TCP_NOPUSH in FreeBSD
   #
-  #   This is enabled by default as of Unicorn 3.4.  This prevents partial
-  #   TCP frames from being sent out and reduces wakeups in nginx if it is
-  #   on a different machine.  Since Unicorn is only designed for applications
-  #   that send the response body quickly without keepalive, sockets will
-  #   always be flushed on close to prevent delays.
+  #   This prevents partial TCP frames from being sent out and reduces
+  #   wakeups in nginx if it is on a different machine.  Since \Unicorn
+  #   is only designed for applications that send the response body
+  #   quickly without keepalive, sockets will always be flushed on close
+  #   to prevent delays.
   #
   #   This has no effect on UNIX sockets.
   #
+  #   Default: +true+ in \Unicorn 3.4+, +false+ in Rainbows!
+  #
   # [:tries => Integer]
   #
   #   Times to retry binding a socket if it is already in use

data/lib/unicorn/const.rb

@@ -8,8 +8,8 @@
 # improve things much compared to constants.
 module Unicorn::Const
 
-  # The current version of Unicorn, currently 3.4.0
-  UNICORN_VERSION = "3.4.0"
+  # The current version of Unicorn, currently 3.6.2
+  UNICORN_VERSION = "3.6.2"
 
   # default TCP listen host address (0.0.0.0, all interfaces)
   DEFAULT_HOST = "0.0.0.0"

data/lib/unicorn/oob_gc.rb

@@ -1,58 +1,69 @@
 # -*- encoding: binary -*-
-module Unicorn
 
-  # Run GC after every request, after closing the client socket and
-  # before attempting to accept more connections.
-  #
-  # This shouldn't hurt overall performance as long as the server cluster
-  # is at <50% CPU capacity, and improves the performance of most memory
-  # intensive requests.  This serves to improve _client-visible_
-  # performance (possibly at the cost of overall performance).
-  #
-  # We'll call GC after each request is been written out to the socket, so
-  # the client never sees the extra GC hit it.
-  #
-  # This middleware is _only_ effective for applications that use a lot
-  # of memory, and will hurt simpler apps/endpoints that can process
-  # multiple requests before incurring GC.
-  #
-  # This middleware is only designed to work with Unicorn, as it harms
-  # keepalive performance.
-  #
-  # Example (in config.ru):
-  #
-  #     require 'unicorn/oob_gc'
-  #
-  #     # GC ever two requests that hit /expensive/foo or /more_expensive/foo
-  #     # in your app.  By default, this will GC once every 5 requests
-  #     # for all endpoints in your app
-  #     use Unicorn::OobGC, 2, %r{\A/(?:expensive/foo|more_expensive/foo)}
-  class OobGC < Struct.new(:app, :interval, :path, :nr, :env, :body)
-
-    def initialize(app, interval = 5, path = %r{\A/})
-      super(app, interval, path, interval)
-    end
-
-    def call(env)
-      status, headers, self.body = app.call(self.env = env)
-      [ status, headers, self ]
-    end
+# Runs GC after requests, after closing the client socket and
+# before attempting to accept more connections.
+#
+# This shouldn't hurt overall performance as long as the server cluster
+# is at <50% CPU capacity, and improves the performance of most memory
+# intensive requests.  This serves to improve _client-visible_
+# performance (possibly at the cost of overall performance).
+#
+# Increasing the number of +worker_processes+ may be necessary to
+# improve average client response times because some of your workers
+# will be busy doing GC and unable to service clients.  Think of
+# using more workers with this module as a poor man's concurrent GC.
+#
+# We'll call GC after each request is been written out to the socket, so
+# the client never sees the extra GC hit it.
+#
+# This middleware is _only_ effective for applications that use a lot
+# of memory, and will hurt simpler apps/endpoints that can process
+# multiple requests before incurring GC.
+#
+# This middleware is only designed to work with unicorn, as it harms
+# performance with keepalive-enabled servers.
+#
+# Example (in config.ru):
+#
+#     require 'unicorn/oob_gc'
+#
+#     # GC ever two requests that hit /expensive/foo or /more_expensive/foo
+#     # in your app.  By default, this will GC once every 5 requests
+#     # for all endpoints in your app
+#     use Unicorn::OobGC, 2, %r{\A/(?:expensive/foo|more_expensive/foo)}
+#
+# Feedback from users of early implementations of this module:
+# * http://comments.gmane.org/gmane.comp.lang.ruby.unicorn.general/486
+# * http://article.gmane.org/gmane.comp.lang.ruby.unicorn.general/596
+module Unicorn::OobGC
 
-    def each
-      body.each { |x| yield x }
+  # this pretends to be Rack middleware because it used to be
+  # But we need to hook into unicorn internals so we need to close
+  # the socket before clearing the request env.
+  #
+  # +interval+ is the number of requests matching the +path+ regular
+  # expression before invoking GC.
+  def self.new(app, interval = 5, path = %r{\A/})
+    @@nr = interval
+    self.const_set :OOBGC_PATH, path
+    self.const_set :OOBGC_INTERVAL, interval
+    ObjectSpace.each_object(Unicorn::HttpServer) do |s|
+      s.extend(self)
+      self.const_set :OOBGC_ENV, s.instance_variable_get(:@request).env
     end
+    app # pretend to be Rack middleware since it was in the past
+  end
 
-    # in Unicorn, this is closed _after_ the client socket
-    def close
-      body.close if body.respond_to?(:close)
-
-      if path =~ env['PATH_INFO'] && ((self.nr -= 1) <= 0)
-        self.nr = interval
-        self.body = nil
-        env.clear
-        GC.start
-      end
+  #:stopdoc:
+  PATH_INFO = "PATH_INFO"
+  def process_client(client)
+    super(client) # Unicorn::HttpServer#process_client
+    if OOBGC_PATH =~ OOBGC_ENV[PATH_INFO] && ((@@nr -= 1) <= 0)
+      @@nr = OOBGC_INTERVAL
+      OOBGC_ENV.clear
+      GC.start
     end
-
   end
+
+  # :startdoc:
 end

data/t/oob_gc.ru

@@ -0,0 +1,21 @@
+#\-E none
+require 'unicorn/oob_gc'
+use Rack::ContentLength
+use Rack::ContentType, "text/plain"
+use Unicorn::OobGC
+$gc_started = false
+
+# Mock GC.start
+def GC.start
+  ObjectSpace.each_object(BasicSocket) do |x|
+    next if Unicorn::HttpServer::LISTENERS.include?(x)
+    x.closed? or abort "not closed #{x}"
+  end
+  $gc_started = true
+end
+run lambda { |env|
+  if "/gc_reset" == env["PATH_INFO"] && "POST" == env["REQUEST_METHOD"]
+    $gc_started = false
+  end
+  [ 200, {}, [ "#$gc_started\n" ] ]
+}

data/t/oob_gc_path.ru

@@ -0,0 +1,21 @@
+#\-E none
+require 'unicorn/oob_gc'
+use Rack::ContentLength
+use Rack::ContentType, "text/plain"
+use Unicorn::OobGC, 5, /BAD/
+$gc_started = false
+
+# Mock GC.start
+def GC.start
+  ObjectSpace.each_object(BasicSocket) do |x|
+    next if Unicorn::HttpServer::LISTENERS.include?(x)
+    x.closed? or abort "not closed #{x}"
+  end
+  $gc_started = true
+end
+run lambda { |env|
+  if "/gc_reset" == env["PATH_INFO"] && "POST" == env["REQUEST_METHOD"]
+    $gc_started = false
+  end
+  [ 200, {}, [ "#$gc_started\n" ] ]
+}

data/t/t9001-oob_gc.sh

@@ -0,0 +1,47 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 9 "OobGC test"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	unicorn -D -c $unicorn_config oob_gc.ru
+	unicorn_wait_start
+}
+
+t_begin "test default interval (4 requests)" && {
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "GC starting-request returns immediately" && {
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "GC is started after 5 requests" && {
+	test xtrue = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "reset GC" && {
+	test xfalse = x$(curl -vsSf -X POST http://$listen/gc_reset 2>> $tmp)
+}
+
+t_begin "test default interval again (3 requests)" && {
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "GC is started after 5 requests" && {
+	test xtrue = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "killing succeeds" && {
+	kill -QUIT $unicorn_pid
+}
+
+t_begin "check_stderr" && check_stderr
+dbgcat r_err
+
+t_done

data/t/t9002-oob_gc-path.sh

@@ -0,0 +1,75 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 12 "OobGC test with limited path"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	unicorn -D -c $unicorn_config oob_gc_path.ru
+	unicorn_wait_start
+}
+
+t_begin "test default is noop" && {
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "4 bad requests to bump counter" && {
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+}
+
+t_begin "GC-starting request returns immediately" && {
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+}
+
+t_begin "GC was started after 5 requests" && {
+	test xtrue = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "reset GC" && {
+	test xfalse = x$(curl -vsSf -X POST http://$listen/gc_reset 2>> $tmp)
+}
+
+t_begin "test default is noop" && {
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "4 bad requests to bump counter" && {
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+}
+
+t_begin "GC-starting request returns immediately" && {
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+}
+
+t_begin "GC was started after 5 requests" && {
+	test xtrue = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "killing succeeds" && {
+	kill -QUIT $unicorn_pid
+}
+
+t_begin "check_stderr" && check_stderr
+
+t_done

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: unicorn
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: 
   segments: 
   - 3
   - 6
-  - 1
-  version: 3.6.1
+  - 2
+  version: 3.6.2
 platform: ruby
 authors: 
 - Unicorn hackers
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-26 00:00:00 Z
+date: 2011-04-30 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rack
@@ -213,6 +213,8 @@ files:
 - t/bin/utee
 - t/env.ru
 - t/my-tap-lib.sh
+- t/oob_gc.ru
+- t/oob_gc_path.ru
 - t/pid.ru
 - t/preread_input.ru
 - t/rack-input-tests.ru
@@ -279,6 +281,8 @@ files:
 - t/t0303-rails3-alt-working_directory_config.ru.sh
 - t/t0304-rails3-alt-working_directory_no_embed_cli.sh
 - t/t9000-preread-input.sh
+- t/t9001-oob_gc.sh
+- t/t9002-oob_gc-path.sh
 - t/test-lib.sh
 - t/test-rails3.sh
 - t/write-on-close.ru