mongrel 0.3.13.3 → 0.3.13.4

data/lib/mongrel/debug.rb

@@ -8,15 +8,22 @@ require 'logger'
 require 'set'
 require 'socket'
 
+
+
 $mongrel_debugging=true
 
 module MongrelDbg
   SETTINGS = { :tracing => {}}
   LOGGING = { }
 
-  def MongrelDbg::configure(log_dir = "log/mongrel_debug")
+  def MongrelDbg::configure(log_dir = File.join("log","mongrel_debug"))
     Dir.mkdir(log_dir) if not File.exist?(log_dir)
     @log_dir = log_dir
+    $objects_out=open(File.join("log","mongrel_debug","objects.log"),"w")
+    $objects_out.puts "run,classname,last,count,delta,lenmean,lensd,lenmax"
+    $objects_out.sync = true
+    $last_stat = nil
+    $run_count = 0
   end
 
   
@@ -47,53 +54,6 @@ module MongrelDbg
 end
 
 
-module ObjectTracker
-  @active_objects = nil
-
-  def ObjectTracker.configure
-    @active_objects = Set.new
-
-    ObjectSpace.each_object do |obj|
-      begin
-        # believe it or not, some idiots actually alter the object_id method
-        @active_objects << obj.object_id
-      rescue Object
-        # skip this one, he's an idiot
-      end
-    end
-  end
-
-  def ObjectTracker.sample
-    ospace = Set.new
-    counts = {}
-    
-    ObjectSpace.each_object do |obj|
-      begin
-        ospace << obj.object_id
-        counts[obj.class] ||= 0
-        counts[obj.class] += 1
-      rescue Object
-        # skip since object_id can magically get parameters
-      end
-    end
-    
-    dead_objects = @active_objects - ospace
-    new_objects = ospace - @active_objects
-    live_objects = ospace & @active_objects
-    
-    MongrelDbg::trace(:objects, "COUNTS: #{dead_objects.length},#{new_objects.length},#{live_objects.length}")
-    
-    if MongrelDbg::tracing? :objects
-      top_20 = counts.sort{|a,b| b[1] <=> a[1]}[0..20]
-      MongrelDbg::trace(:objects,"TOP 20: #{top_20.inspect}")
-    end
-    
-    @active_objects = live_objects + new_objects
-    
-    [@active_objects, top_20]
-  end
-
-end
 
 $open_files = {}
 
@@ -157,20 +117,51 @@ module RequestLog
     
   end
 
+  # stolen from Robert Klemme
   class Objects < GemPlugin::Plugin "/handlers"
     include Mongrel::HttpHandlerPlugin
-    
-    def process(request, response)
-      MongrelDbg::trace(:objects, "#{'-' * 10}\n#{Time.now} OBJECT STATS BEFORE REQUEST #{request.params['PATH_INFO']}")
-      ObjectTracker.sample
+
+    def process(request,response)
+      begin
+        stats = Hash.new(0)
+        lengths = {}
+        ObjectSpace.each_object do |o| 
+          begin
+            if o.respond_to? :length
+              len = o.length
+              lengths[o.class] ||= Mongrel::Stats.new(o.class)
+              lengths[o.class].sample(len)
+            end
+          rescue Object
+          end
+
+          stats[o.class] += 1
+        end
+
+        stats.sort {|(k1,v1),(k2,v2)| v2 <=> v1}.each do |k,v|
+          if $last_stat
+            delta = v - $last_stat[k]
+            if v > 10 and delta != 0
+              if lengths[k]
+                $objects_out.printf "%d,%s,%d,%d,%d,%f,%f,%f\n", $run_count, k, $last_stat[k], v, delta,lengths[k].mean,lengths[k].sd,lengths[k].max
+              else
+                $objects_out.printf "%d,%s,%d,%d,%d,,,\n", $run_count, k, $last_stat[k], v, delta
+              end
+            end
+          end
+        end
+
+        $run_count += 1
+        $last_stat = stats
+      rescue Object
+        STDERR.puts "object.log ERROR: #$!"
+      end
     end
-    
   end
-  
 
   class Params < GemPlugin::Plugin "/handlers"
     include Mongrel::HttpHandlerPlugin
-    
+
     def process(request, response)
       MongrelDbg::trace(:rails, "#{Time.now} REQUEST #{request.params['PATH_INFO']}")
       MongrelDbg::trace(:rails, request.params.to_yaml)
@@ -180,7 +171,7 @@ module RequestLog
 
   class Threads < GemPlugin::Plugin "/handlers"
     include Mongrel::HttpHandlerPlugin
-    
+
     def process(request, response)
       MongrelDbg::trace(:threads, "#{Time.now} REQUEST #{request.params['PATH_INFO']}")
       ObjectSpace.each_object do |obj|

data/lib/mongrel/handlers.rb

@@ -173,14 +173,10 @@ module Mongrel
           head[Const::CONTENT_TYPE] = "text/html"
           out << "<html><head><title>Directory Listing</title></head><body>"
           Dir.entries(dir).each do |child|
-            child = HttpRequest.unescape(child)
             next if child == "."
-
-            if child == ".."
-              out << "<a href=\"#{base}/#{child}\">Up to parent..</a><br/>"
-            else
-              out << "<a href=\"#{base}/#{child}/\">#{child}</a><br/>"
-            end
+            out << "<a href=\"#{base}/#{ HttpRequest.escape(child)}\">"
+            out << (child == ".." ? "Up to parent.." : child)
+            out << "</a><br/>"
           end
           out << "</body></html>"
         end
@@ -203,18 +199,18 @@ module Mongrel
       # Calculated the same as apache, not sure how well the works on win32
       etag = Const::ETAG_FORMAT % [mtime.to_i, stat.size, stat.ino]
 
-      unmodified_since = request.params[Const::HTTP_IF_UNMODIFIED_SINCE]
+      modified_since = request.params[Const::HTTP_IF_MODIFIED_SINCE]
       none_match = request.params[Const::HTTP_IF_NONE_MATCH]
 
       # test to see if this is a conditional request, and test if
       # the response would be identical to the last response
       same_response = case
-                      when unmodified_since && !last_response_time = Time.httpdate(unmodified_since) rescue nil : false
-                      when unmodified_since && last_response_time > Time.now                                    : false
-                      when unmodified_since && mtime > last_response_time                                       : false
-                      when none_match       && none_match == '*'                                                : false
-                      when none_match       && !none_match.strip.split(/\s*,\s*/).include?(etag)                : false
-                      else unmodified_since || none_match  # validation successful if we get this far and at least one of the header exists
+                      when modified_since && !last_response_time = Time.httpdate(modified_since) rescue nil : false
+                      when modified_since && last_response_time > Time.now                                  : false
+                      when modified_since && mtime > last_response_time                                     : false
+                      when none_match     && none_match == '*'                                              : false
+                      when none_match     && !none_match.strip.split(/\s*,\s*/).include?(etag)              : false
+                      else modified_since || none_match  # validation successful if we get this far and at least one of the header exists
                       end
 
       header = response.header
@@ -238,7 +234,7 @@ module Mongrel
         response.send_header
 
         if not header_only
-          response.send_file(req_path)
+          response.send_file(req_path, stat.size < Const::CHUNK_SIZE * 2)
         end
       end
     end
@@ -328,11 +324,11 @@ module Mongrel
     def initialize(ops={})
       @sample_rate = ops[:sample_rate] || 300
 
-      @processors = Stats.new("processors")
-      @reqsize = Stats.new("request Kb")
-      @headcount = Stats.new("req param count")
-      @respsize = Stats.new("response Kb")
-      @interreq = Stats.new("inter-request time")
+      @processors = Mongrel::Stats.new("processors")
+      @reqsize = Mongrel::Stats.new("request Kb")
+      @headcount = Mongrel::Stats.new("req param count")
+      @respsize = Mongrel::Stats.new("response Kb")
+      @interreq = Mongrel::Stats.new("inter-request time")
     end
 
 

data/lib/mongrel/rails.rb

@@ -6,6 +6,12 @@
 
 require 'mongrel'
 require 'cgi'
+require 'sync'
+
+class Sync
+  # modified to open the waiting list for reporting purposes
+  attr_accessor :sync_waiting
+end
 
 module Mongrel
   module Rails
@@ -36,7 +42,8 @@ module Mongrel
 
       def initialize(dir, mime_map = {})
         @files = Mongrel::DirHandler.new(dir,false)
-        @guard = Mutex.new
+        @guard = Sync.new
+        @tick = Time.now
 
         # register the requested mime types
         mime_map.each {|k,v| Mongrel::DirHandler::add_mime_type(k,v) }
@@ -49,7 +56,9 @@ module Mongrel
       # * If it exists at PATH_INFO+".html" exists then serve that.
       # * Finally, construct a Mongrel::CGIWrapper and run Dispatcher.dispatch to have Rails go.
       def process(request, response)
-        return if response.socket.closed?
+        if response.socket.closed?
+          return
+        end
 
         path_info = request.params[Mongrel::Const::PATH_INFO]
         page_cached = path_info + ".html"
@@ -59,41 +68,50 @@ module Mongrel
           # File exists as-is so serve it up
           @files.process(request,response)
         elsif get_or_head and @files.can_serve(page_cached)
-          # possible cached page, serve it up      
+          # possible cached page, serve it up
           request.params[Mongrel::Const::PATH_INFO] = page_cached
           @files.process(request,response)
         else
           begin
             cgi = Mongrel::CGIWrapper.new(request, response)
             cgi.handler = self
+            # we don't want the output to be really final until we're out of the lock
+            cgi.default_really_final = false
 
-            # ultra dangerous, but people are asking to kill themselves.  here's the Katana
-            @guard.lock unless ActionController::Base.allow_concurrency
+            log_threads_waiting_for(request.params["PATH_INFO"]) if $mongrel_debug_client
 
-            Dispatcher.dispatch(cgi, ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, response.body)
+            @guard.synchronize(:EX) {
+              Dispatcher.dispatch(cgi, ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, response.body)
+            }
 
             # This finalizes the output using the proper HttpResponse way
-            cgi.out {""}
+            cgi.out("text/html",true) {""}
           rescue Errno::EPIPE
-            # ignored
+            response.socket.close
           rescue Object => rails_error
-            STDERR.puts "Error calling Dispatcher.dispatch #{rails_error.inspect}"
+            STDERR.puts "#{Time.now}: Error calling Dispatcher.dispatch #{rails_error.inspect}"
             STDERR.puts rails_error.backtrace.join("\n")
-          ensure
-            @guard.unlock unless ActionController::Base.allow_concurrency
           end
         end
       end
 
+      def log_threads_waiting_for(event)
+        if Time.now - @tick > 10
+          STDERR.puts "#{Time.now}: #{@guard.sync_waiting.length} threads sync_waiting for #{event}, #{self.listener.workers.list.length} still active in mongrel."
+          @tick = Time.now
+        end
+      end
 
       # Does the internal reload for Rails.  It might work for most cases, but
       # sometimes you get exceptions.  In that case just do a real restart.
       def reload!
-        @guard.synchronize do
-          $".replace $orig_dollar_quote
-          GC.start
-          Dispatcher.reset_application!
-          ActionController::Routing::Routes.reload
+        begin
+          @guard.synchronize(:EX) {
+            $".replace $orig_dollar_quote
+            GC.start
+            Dispatcher.reset_application!
+            ActionController::Routing::Routes.reload
+          }
         end
       end
     end
@@ -137,7 +155,6 @@ module Mongrel
         ops[:docroot] ||= "public"
         ops[:mime] ||= {}
 
-
         $orig_dollar_quote = $".clone
         ENV['RAILS_ENV'] = ops[:environment]
         env_location = "#{ops[:cwd]}/config/environment"
@@ -145,9 +162,8 @@ module Mongrel
         require 'dispatcher'
         require 'mongrel/rails'
 
-        if ActionController::Base.allow_concurrency
-          log "[RAILS] ActionController::Base.allow_concurrency is true.  Wow, you're very brave."
-        end
+        ActionController::AbstractRequest.relative_url_root = ops[:prefix] if ops[:prefix]
+
         @rails_handler = RailsHandler.new(ops[:docroot], ops[:mime])
       end
 

data/lib/mongrel/stats.rb

@@ -12,76 +12,78 @@
 #
 # It does all of this very fast and doesn't take up any memory since the samples
 # are not stored but instead all the values are calculated on the fly.
-class Stats
-  attr_reader :sum, :sumsq, :n, :min, :max
+module Mongrel
+  class Stats
+    attr_reader :sum, :sumsq, :n, :min, :max
 
-  def initialize(name)
-    @name = name
-    reset
-  end
+    def initialize(name)
+      @name = name
+      reset
+    end
 
-  # Resets the internal counters so you can start sampling again.
-  def reset
-    @sum = 0.0
-    @sumsq = 0.0
-    @last_time = Time.new
-    @n = 0.0
-    @min = 0.0
-    @max = 0.0
-  end
+    # Resets the internal counters so you can start sampling again.
+    def reset
+      @sum = 0.0
+      @sumsq = 0.0
+      @last_time = Time.new
+      @n = 0.0
+      @min = 0.0
+      @max = 0.0
+    end
 
-  # Adds a sampling to the calculations.
-  def sample(s)
-    @sum += s
-    @sumsq += s * s
-    if @n == 0
-      @min = @max = s
-    else
-      @min = s if @min > s
-      @max = s if @max < s
+    # Adds a sampling to the calculations.
+    def sample(s)
+      @sum += s
+      @sumsq += s * s
+      if @n == 0
+        @min = @max = s
+      else
+        @min = s if @min > s
+        @max = s if @max < s
+      end
+      @n+=1
     end
-    @n+=1
-  end
 
-  # Dump this Stats object with an optional additional message.
-  def dump(msg = "", out=STDERR)
-    out.puts "#{msg}: #{self.to_s}"
-  end
+    # Dump this Stats object with an optional additional message.
+    def dump(msg = "", out=STDERR)
+      out.puts "#{msg}: #{self.to_s}"
+    end
 
-  # Returns a common display (used by dump)
-  def to_s  
+    # Returns a common display (used by dump)
+    def to_s  
     "[#{@name}]: SUM=%0.4f, SUMSQ=%0.4f, N=%0.4f, MEAN=%0.4f, SD=%0.4f, MIN=%0.4f, MAX=%0.4f" % [@sum, @sumsq, @n, mean, sd, @min, @max]
-  end
+    end
 
 
-  # Calculates and returns the mean for the data passed so far.
-  def mean
-    @sum / @n
-  end
+    # Calculates and returns the mean for the data passed so far.
+    def mean
+      @sum / @n
+    end
 
-  # Calculates the standard deviation of the data so far.
-  def sd
-    # (sqrt( ((s).sumsq - ( (s).sum * (s).sum / (s).n)) / ((s).n-1) ))
-    begin
-      return Math.sqrt( (@sumsq - ( @sum * @sum / @n)) / (@n-1) )
-    rescue Errno::EDOM
-      return 0.0
+    # Calculates the standard deviation of the data so far.
+    def sd
+      # (sqrt( ((s).sumsq - ( (s).sum * (s).sum / (s).n)) / ((s).n-1) ))
+      begin
+        return Math.sqrt( (@sumsq - ( @sum * @sum / @n)) / (@n-1) )
+      rescue Errno::EDOM
+        return 0.0
+      end
     end
-  end
 
 
-  # Adds a time delta between now and the last time you called this.  This
-  # will give you the average time between two activities.
-  # 
-  # An example is:
-  #
-  #  t = Stats.new("do_stuff")
-  #  10000.times { do_stuff(); t.tick }
-  #  t.dump("time")
-  #
-  def tick
-    now = Time.now
-    sample(now - @last_time)
-    @last_time = now
+    # Adds a time delta between now and the last time you called this.  This
+    # will give you the average time between two activities.
+    # 
+    # An example is:
+    #
+    #  t = Stats.new("do_stuff")
+    #  10000.times { do_stuff(); t.tick }
+    #  t.dump("time")
+    #
+    def tick
+      now = Time.now
+      sample(now - @last_time)
+      @last_time = now
+    end
   end
 end