unicorn 3.6.0 → 4.0.0

data/lib/unicorn/http_server.rb

@@ -23,9 +23,6 @@ class Unicorn::HttpServer
   # backwards compatibility with 1.x
   Worker = Unicorn::Worker
 
-  # prevents IO objects in here from being GC-ed
-  IO_PURGATORY = []
-
   # all bound listener sockets
   LISTENERS = []
 
@@ -100,7 +97,7 @@ class Unicorn::HttpServer
     self.reexec_pid = 0
     options = options.dup
     @ready_pipe = options.delete(:ready_pipe)
-    self.init_listeners = options[:listeners] ? options[:listeners].dup : []
+    @init_listeners = options[:listeners] ? options[:listeners].dup : []
     options[:use_defaults] = true
     self.config = Unicorn::Configurator.new(options)
     self.listener_opts = {}
@@ -121,35 +118,7 @@ class Unicorn::HttpServer
 
   # Runs the thing.  Returns self so you can run join on it
   def start
-    BasicSocket.do_not_reverse_lookup = true
-
-    # inherit sockets from parents, they need to be plain Socket objects
-    # before they become Kgio::UNIXServer or Kgio::TCPServer
-    inherited = ENV['UNICORN_FD'].to_s.split(/,/).map do |fd|
-      io = Socket.for_fd(fd.to_i)
-      set_server_sockopt(io, listener_opts[sock_name(io)])
-      IO_PURGATORY << io
-      logger.info "inherited addr=#{sock_name(io)} fd=#{fd}"
-      server_cast(io)
-    end
-
-    config_listeners = config[:listeners].dup
-    LISTENERS.replace(inherited)
-
-    # we start out with generic Socket objects that get cast to either
-    # Kgio::TCPServer or Kgio::UNIXServer objects; but since the Socket
-    # objects share the same OS-level file descriptor as the higher-level
-    # *Server objects; we need to prevent Socket objects from being
-    # garbage-collected
-    config_listeners -= listener_names
-    if config_listeners.empty? && LISTENERS.empty?
-      config_listeners << Unicorn::Const::DEFAULT_LISTEN
-      init_listeners << Unicorn::Const::DEFAULT_LISTEN
-      START_CTX[:argv] << "-l#{Unicorn::Const::DEFAULT_LISTEN}"
-    end
-    config_listeners.each { |addr| listen(addr) }
-    raise ArgumentError, "no listeners" if LISTENERS.empty?
-
+    inherit_listeners!
     # this pipe is used to wake us up from select(2) in #join when signals
     # are trapped.  See trap_deferred.
     init_self_pipe!
@@ -163,7 +132,7 @@ class Unicorn::HttpServer
 
     self.master_pid = $$
     build_app! if preload_app
-    maintain_worker_count
+    spawn_missing_workers
     self
   end
 
@@ -284,8 +253,7 @@ class Unicorn::HttpServer
     logger.info "master process ready" # test_exec.rb relies on this message
     if @ready_pipe
       @ready_pipe.syswrite($$.to_s)
-      @ready_pipe.close rescue nil
-      @ready_pipe = nil
+      @ready_pipe = @ready_pipe.close rescue nil
     end
     begin
       reap_all_workers
@@ -336,10 +304,8 @@ class Unicorn::HttpServer
           reexec
         end
       end
-    rescue Errno::EINTR
     rescue => e
-      logger.error "Unhandled master loop exception #{e.inspect}."
-      logger.error e.backtrace.join("\n")
+      Unicorn.log_error(@logger, "master loop error", e)
     end while true
     stop # gracefully shutdown all workers on our way out
     logger.info "master complete"
@@ -406,7 +372,7 @@ class Unicorn::HttpServer
         self.pid = pid.chomp('.oldbin') if pid
         proc_name 'master'
       else
-        worker = WORKERS.delete(wpid) and worker.tmp.close rescue nil
+        worker = WORKERS.delete(wpid) and worker.close rescue nil
         m = "reaped #{status.inspect} worker=#{worker.nr rescue 'unknown'}"
         status.success? ? logger.info(m) : logger.error(m)
       end
@@ -463,22 +429,17 @@ class Unicorn::HttpServer
     proc_name 'master (old)'
   end
 
-  # forcibly terminate all workers that haven't checked in in timeout
-  # seconds.  The timeout is implemented using an unlinked File
-  # shared between the parent process and each worker.  The worker
-  # runs File#chmod to modify the ctime of the File.  If the ctime
-  # is stale for >timeout seconds, then we'll kill the corresponding
-  # worker.
+  # forcibly terminate all workers that haven't checked in in timeout seconds.  The timeout is implemented using an unlinked File
   def murder_lazy_workers
     t = @timeout
     next_sleep = 1
+    now = Time.now.to_i
     WORKERS.dup.each_pair do |wpid, worker|
-      stat = worker.tmp.stat
-      # skip workers that disable fchmod or have never fchmod-ed
-      stat.mode == 0100600 and next
-      diff = Time.now - stat.ctime
-      if diff <= t
-        tmp = t - diff
+      tick = worker.tick
+      0 == tick and next # skip workers that are sleeping
+      diff = now - tick
+      tmp = t - diff
+      if tmp >= 0
         next_sleep < tmp and next_sleep = tmp
         next
       end
@@ -491,24 +452,33 @@ class Unicorn::HttpServer
 
   def after_fork_internal
     @ready_pipe.close if @ready_pipe
-    self.ready_pipe = nil # XXX Rainbows! compat, change for Unicorn 4.x
-    tmp = srand # http://redmine.ruby-lang.org/issues/4338
+    Unicorn::Configurator::RACKUP.clear
+    @ready_pipe = @init_listeners = @config = @before_exec = @before_fork = nil
+
+    srand # http://redmine.ruby-lang.org/issues/4338
 
     # The OpenSSL PRNG is seeded with only the pid, and apps with frequently
     # dying workers can recycle pids
-    OpenSSL::Random.seed(tmp.to_s) if defined?(OpenSSL::Random)
+    OpenSSL::Random.seed(rand.to_s) if defined?(OpenSSL::Random)
   end
 
   def spawn_missing_workers
-    (0...worker_processes).each do |worker_nr|
-      WORKERS.values.include?(worker_nr) and next
-      worker = Worker.new(worker_nr, Unicorn::TmpIO.new)
+    worker_nr = -1
+    until (worker_nr += 1) == @worker_processes
+      WORKERS.value?(worker_nr) and next
+      worker = Worker.new(worker_nr)
       before_fork.call(self, worker)
-      WORKERS[fork {
+      if pid = fork
+        WORKERS[pid] = worker
+      else
         after_fork_internal
         worker_loop(worker)
-      }] = worker
+        exit
+      end
     end
+    rescue => e
+      @logger.error(e) rescue nil
+      exit!
   end
 
   def maintain_worker_count
@@ -527,11 +497,14 @@ class Unicorn::HttpServer
     msg = case e
     when EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
       Unicorn::Const::ERROR_500_RESPONSE
+    when Unicorn::RequestURITooLongError
+      Unicorn::Const::ERROR_414_RESPONSE
+    when Unicorn::RequestEntityTooLargeError
+      Unicorn::Const::ERROR_413_RESPONSE
     when Unicorn::HttpParserError # try to tell the client they're bad
       Unicorn::Const::ERROR_400_RESPONSE
     else
-      logger.error "Read error: #{e.inspect}"
-      logger.error e.backtrace.join("\n")
+      Unicorn.log_error(@logger, "app error", e)
       Unicorn::Const::ERROR_500_RESPONSE
     end
     client.kgio_trywrite(msg)
@@ -567,10 +540,8 @@ class Unicorn::HttpServer
     proc_name "worker[#{worker.nr}]"
     START_CTX.clear
     init_self_pipe!
-    WORKERS.values.each { |other| other.tmp.close rescue nil }
     WORKERS.clear
     LISTENERS.each { |sock| sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
-    worker.tmp.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
     after_fork.call(self, worker) # can drop perms
     worker.user(*user) if user.kind_of?(Array) && ! worker.switched
     self.timeout /= 2.0 # halve it for select()
@@ -594,35 +565,25 @@ class Unicorn::HttpServer
     ppid = master_pid
     init_worker_process(worker)
     nr = 0 # this becomes negative if we need to reopen logs
-    alive = worker.tmp # tmp is our lifeline to the master process
-    ready = LISTENERS
+    l = LISTENERS.dup
+    ready = l.dup
 
     # closing anything we IO.select on will raise EBADF
     trap(:USR1) { nr = -65536; SELF_PIPE[0].close rescue nil }
-    trap(:QUIT) { alive = nil; LISTENERS.each { |s| s.close rescue nil }.clear }
+    trap(:QUIT) { worker = nil; LISTENERS.each { |s| s.close rescue nil }.clear }
     [:TERM, :INT].each { |sig| trap(sig) { exit!(0) } } # instant shutdown
     logger.info "worker=#{worker.nr} ready"
-    m = 0
 
     begin
       nr < 0 and reopen_worker_logs(worker.nr)
       nr = 0
 
-      # we're a goner in timeout seconds anyways if alive.chmod
-      # breaks, so don't trap the exception.  Using fchmod() since
-      # futimes() is not available in base Ruby and I very strongly
-      # prefer temporary files to be unlinked for security,
-      # performance and reliability reasons, so utime is out.  No-op
-      # changes with chmod doesn't update ctime on all filesystems; so
-      # we change our counter each and every time (after process_client
-      # and before IO.select).
-      alive.chmod(m = 0 == m ? 1 : 0)
-
-      ready.each do |sock|
+      worker.tick = Time.now.to_i
+      while sock = ready.shift
         if client = sock.kgio_tryaccept
           process_client(client)
           nr += 1
-          alive.chmod(m = 0 == m ? 1 : 0)
+          worker.tick = Time.now.to_i
         end
         break if nr < 0
       end
@@ -631,23 +592,21 @@ class Unicorn::HttpServer
       # we're probably reasonably busy, so avoid calling select()
       # and do a speculative non-blocking accept() on ready listeners
       # before we sleep again in select().
-      redo unless nr == 0 # (nr < 0) => reopen logs
+      unless nr == 0 # (nr < 0) => reopen logs (unlikely)
+        ready = l.dup
+        redo
+      end
 
       ppid == Process.ppid or return
-      alive.chmod(m = 0 == m ? 1 : 0)
 
       # timeout used so we can detect parent death:
-      ret = IO.select(LISTENERS, nil, SELF_PIPE, timeout) and ready = ret[0]
-    rescue Errno::EINTR
-      ready = LISTENERS
+      worker.tick = Time.now.to_i
+      ret = IO.select(l, nil, SELF_PIPE, @timeout) and ready = ret[0]
     rescue Errno::EBADF
       nr < 0 or return
     rescue => e
-      if alive
-        logger.error "Unhandled listen loop exception #{e.inspect}."
-        logger.error e.backtrace.join("\n")
-      end
-    end while alive
+      Unicorn.log_error(@logger, "listen loop error", e) if worker
+    end while worker
   end
 
   # delivers a signal to a worker and fails gracefully if the worker
@@ -655,7 +614,7 @@ class Unicorn::HttpServer
   def kill_worker(signal, wpid)
     Process.kill(signal, wpid)
     rescue Errno::ESRCH
-      worker = WORKERS.delete(wpid) and worker.tmp.close rescue nil
+      worker = WORKERS.delete(wpid) and worker.close rescue nil
   end
 
   # delivers a signal to each worker
@@ -685,7 +644,7 @@ class Unicorn::HttpServer
   def load_config!
     loaded_app = app
     logger.info "reloading config_file=#{config.config_file}"
-    config[:listeners].replace(init_listeners)
+    config[:listeners].replace(@init_listeners)
     config.reload
     config.commit!(self)
     kill_each_worker(:QUIT)
@@ -694,8 +653,8 @@ class Unicorn::HttpServer
     build_app! if preload_app
     logger.info "done reloading config_file=#{config.config_file}"
   rescue StandardError, LoadError, SyntaxError => e
-    logger.error "error reloading config_file=#{config.config_file}: " \
-                 "#{e.class} #{e.message} #{e.backtrace}"
+    Unicorn.log_error(@logger,
+        "error reloading config_file=#{config.config_file}", e)
     self.app = loaded_app
   end
 
@@ -729,5 +688,33 @@ class Unicorn::HttpServer
     SELF_PIPE.replace(Kgio::Pipe.new)
     SELF_PIPE.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
   end
-end
 
+  def inherit_listeners!
+    # inherit sockets from parents, they need to be plain Socket objects
+    # before they become Kgio::UNIXServer or Kgio::TCPServer
+    inherited = ENV['UNICORN_FD'].to_s.split(/,/).map do |fd|
+      io = Socket.for_fd(fd.to_i)
+      set_server_sockopt(io, listener_opts[sock_name(io)])
+      IO_PURGATORY << io
+      logger.info "inherited addr=#{sock_name(io)} fd=#{fd}"
+      server_cast(io)
+    end
+
+    config_listeners = config[:listeners].dup
+    LISTENERS.replace(inherited)
+
+    # we start out with generic Socket objects that get cast to either
+    # Kgio::TCPServer or Kgio::UNIXServer objects; but since the Socket
+    # objects share the same OS-level file descriptor as the higher-level
+    # *Server objects; we need to prevent Socket objects from being
+    # garbage-collected
+    config_listeners -= listener_names
+    if config_listeners.empty? && LISTENERS.empty?
+      config_listeners << Unicorn::Const::DEFAULT_LISTEN
+      @init_listeners << Unicorn::Const::DEFAULT_LISTEN
+      START_CTX[:argv] << "-l#{Unicorn::Const::DEFAULT_LISTEN}"
+    end
+    config_listeners.each { |addr| listen(addr) }
+    raise ArgumentError, "no listeners" if LISTENERS.empty?
+  end
+end

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/lib/unicorn/socket_helper.rb

@@ -4,9 +4,12 @@ require 'socket'
 
 module Unicorn
   module SocketHelper
+    # :stopdoc:
     include Socket::Constants
 
-    # :stopdoc:
+    # prevents IO objects in here from being GC-ed
+    IO_PURGATORY = []
+
     # internal interface, only used by Rainbows!/Zbatery
     DEFAULTS = {
       # The semantics for TCP_DEFER_ACCEPT changed in Linux 2.6.32+
@@ -24,9 +27,9 @@ module Unicorn
       # same default value as Mongrel
       :backlog => 1024,
 
-      # since we don't do keepalive, we'll always flush-on-close and
-      # this saves packets for everyone.
-      :tcp_nopush => true,
+      # favor latency over bandwidth savings
+      :tcp_nopush => false,
+      :tcp_nodelay => true,
     }
     #:startdoc:
 
@@ -98,8 +101,7 @@ module Unicorn
       end
       sock.listen(opt[:backlog])
       rescue => e
-        logger.error "error setting socket options: #{e.inspect}"
-        logger.error e.backtrace.join("\n")
+        Unicorn.log_error(logger, message, e)
     end
 
     def log_buffer_sizes(sock, pfx = '')
@@ -136,8 +138,9 @@ module Unicorn
         ensure
           File.umask(old_umask)
         end
-      elsif /\A(\d+\.\d+\.\d+\.\d+):(\d+)\z/ =~ address ||
-            /\A\[([a-fA-F0-9:]+)\]:(\d+)\z/ =~ address
+      elsif /\A\[([a-fA-F0-9:]+)\]:(\d+)\z/ =~ address
+        new_ipv6_server($1, $2.to_i, opt)
+      elsif /\A(\d+\.\d+\.\d+\.\d+):(\d+)\z/ =~ address
         Kgio::TCPServer.new($1, $2.to_i)
       else
         raise ArgumentError, "Don't know how to bind: #{address}"
@@ -146,6 +149,18 @@ module Unicorn
       sock
     end
 
+    def new_ipv6_server(addr, port, opt)
+      opt.key?(:ipv6only) or return Kgio::TCPServer.new(addr, port)
+      defined?(IPV6_V6ONLY) or
+        abort "Socket::IPV6_V6ONLY not defined, upgrade Ruby and/or your OS"
+      sock = Socket.new(AF_INET6, SOCK_STREAM, 0)
+      sock.setsockopt(IPPROTO_IPV6, IPV6_V6ONLY, opt[:ipv6only] ? 1 : 0)
+      sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+      sock.bind(Socket.pack_sockaddr_in(port, addr))
+      IO_PURGATORY << sock
+      Kgio::TCPServer.for_fd(sock.fileno)
+    end
+
     # returns rfc2732-style (e.g. "[::1]:666") addresses for IPv6
     def tcp_name(sock)
       port, addr = Socket.unpack_sockaddr_in(sock.getsockname)

data/lib/unicorn/worker.rb

@@ -1,4 +1,5 @@
 # -*- encoding: binary -*-
+require "raindrops"
 
 # This class and its members can be considered a stable interface
 # and will not change in a backwards-incompatible fashion between
@@ -7,13 +8,53 @@
 #
 # Some users may want to access it in the before_fork/after_fork hooks.
 # See the Unicorn::Configurator RDoc for examples.
-class Unicorn::Worker < Struct.new(:nr, :tmp, :switched)
+class Unicorn::Worker
+  # :stopdoc:
+  attr_accessor :nr, :switched
+  attr_writer :tmp
+
+  PER_DROP = Raindrops::PAGE_SIZE / Raindrops::SIZE
+  DROPS = []
+
+  def initialize(nr)
+    drop_index = nr / PER_DROP
+    @raindrop = DROPS[drop_index] ||= Raindrops.new(PER_DROP)
+    @offset = nr % PER_DROP
+    @raindrop[@offset] = 0
+    @nr = nr
+    @tmp = @switched = false
+  end
 
   # worker objects may be compared to just plain Integers
   def ==(other_nr) # :nodoc:
-    nr == other_nr
+    @nr == other_nr
+  end
+
+  # called in the worker process
+  def tick=(value) # :nodoc:
+    @raindrop[@offset] = value
+  end
+
+  # called in the master process
+  def tick # :nodoc:
+    @raindrop[@offset]
   end
 
+  # only exists for compatibility
+  def tmp # :nodoc:
+    @tmp ||= begin
+      tmp = Unicorn::TmpIO.new
+      tmp.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      tmp
+    end
+  end
+
+  def close # :nodoc:
+    @tmp.close if @tmp
+  end
+
+  # :startdoc:
+
   # In most cases, you should be using the Unicorn::Configurator#user
   # directive instead.  This method should only be used if you need
   # fine-grained control of exactly when you want to change permissions
@@ -36,12 +77,12 @@ class Unicorn::Worker < Struct.new(:nr, :tmp, :switched)
     uid = Etc.getpwnam(user).uid
     gid = Etc.getgrnam(group).gid if group
     Unicorn::Util.chown_logs(uid, gid)
-    tmp.chown(uid, gid)
+    @tmp.chown(uid, gid) if @tmp
     if gid && Process.egid != gid
       Process.initgroups(user, gid)
       Process::GID.change_privilege(gid)
     end
     Process.euid != uid and Process::UID.change_privilege(uid)
-    self.switched = true
+    @switched = true
   end
 end

data/lib/unicorn.rb

@@ -26,17 +26,14 @@ module Unicorn
   end
 
   # :stopdoc:
-  def self.run(app, options = {})
-    Unicorn::HttpServer.new(app, options).start.join
-  end
 
   # This returns a lambda to pass in as the app, this does not "build" the
   # app (which we defer based on the outcome of "preload_app" in the
   # Unicorn config).  The returned lambda will be called when it is
   # time to build the app.
-  def self.builder(ru, opts)
+  def self.builder(ru, op)
     # allow Configurator to parse cli switches embedded in the ru file
-    Unicorn::Configurator::RACKUP.update(:file => ru, :optparse => opts)
+    op = Unicorn::Configurator::RACKUP.merge!(:file => ru, :optparse => op)
 
     # always called after config file parsing, may be called after forking
     lambda do ||
@@ -44,7 +41,7 @@ module Unicorn
       when /\.ru$/
         raw = File.read(ru)
         raw.sub!(/^__END__\n.*/, '')
-        eval("Rack::Builder.new {(#{raw}\n)}.to_app", TOPLEVEL_BINDING, ru)
+        eval("Rack::Builder.new {(\n#{raw}\n)}.to_app", TOPLEVEL_BINDING, ru)
       else
         require ru
         Object.const_get(File.basename(ru, '.rb').capitalize)
@@ -80,6 +77,11 @@ module Unicorn
       Unicorn::SocketHelper.sock_name(io)
     end
   end
+
+  def self.log_error(logger, message, exc)
+    logger.error "#{message}: #{exc.message} (#{exc.class})"
+    exc.backtrace.each { |line| logger.error(line) }
+  end
   # :startdoc:
 end
 # :enddoc:

data/script/isolate_for_tests

@@ -17,8 +17,9 @@ opts = {
 pid = fork do
   Isolate.now!(opts) do
     gem 'sqlite3-ruby', '1.2.5'
-    gem 'kgio', '2.3.3'
-    gem 'rack', '1.2.2'
+    gem 'raindrops', '0.6.1'
+    gem 'kgio', '2.5.0'
+    gem 'rack', '1.3.0'
   end
 end
 _, status = Process.waitpid2(pid)
@@ -35,6 +36,7 @@ File.rename("#{dst}.#$$", dst)
   opts[:path] = "tmp/isolate/rails-#{rails_ver}"
   pid = fork do
     Isolate.now!(opts) do
+      gem 'rake', '0.8.7'
       gem 'rails', rails_ver
     end
   end

data/t/broken-app.ru

@@ -0,0 +1,12 @@
+# we do not want Rack::Lint or anything to protect us
+use Rack::ContentLength
+use Rack::ContentType, "text/plain"
+map "/" do
+  run lambda { |env| [ 200, {}, [ "OK\n" ] ] }
+end
+map "/raise" do
+  run lambda { |env| raise "BAD" }
+end
+map "/nil" do
+  run lambda { |env| nil }
+end