buffered_logger.rb in radiant-0.8.0

- old
+ new

@@ -11,10 +11,12 @@
     end
     include Severity
 
     MAX_BUFFER_SIZE = 1000
 
+    ##
+    # :singleton-method:
     # Set to false to disable the silencer
     cattr_accessor :silencer
     self.silencer = true
 
     # Silences the logger for the duration of the block.
@@ -31,17 +33,16 @@
       end
     end
 
     attr_accessor :level
     attr_reader :auto_flushing
-    attr_reader :buffer
 
     def initialize(log, level = DEBUG)
       @level         = level
-      @buffer        = []
+      @buffer        = {}
       @auto_flushing = 1
-      @no_block = false
+      @guard = Mutex.new
 
       if log.respond_to?(:write)
         @log = log
       elsif File.exist?(log)
         @log = open(log, (File::WRONLY | File::APPEND))
@@ -52,16 +53,10 @@
         @log.sync = true
         @log.write("# Logfile created on %s" % [Time.now.to_s])
       end
     end
 
-    def set_non_blocking_io
-      if !RUBY_PLATFORM.match(/java|mswin/) && !(@log == STDOUT) && @log.respond_to?(:write_nonblock)
-        @no_block = true
-      end
-    end
-
     def add(severity, message = nil, progname = nil, &block)
       return if @level > severity
       message = (message || (block && block.call) || progname).to_s
       # If a newline is necessary then create a new message ending with a newline.
       # Ensures that the original message is not mutated.
@@ -71,17 +66,17 @@
       message
     end
 
     for severity in Severity.constants
       class_eval <<-EOT, __FILE__, __LINE__
-        def #{severity.downcase}(message = nil, progname = nil, &block)
-          add(#{severity}, message, progname, &block)
-        end
-
-        def #{severity.downcase}?
-          #{severity} >= @level
-        end
+        def #{severity.downcase}(message = nil, progname = nil, &block)  # def debug(message = nil, progname = nil, &block)
+          add(#{severity}, message, progname, &block)                    #   add(DEBUG, message, progname, &block)
+        end                                                              # end
+                                                                         #
+        def #{severity.downcase}?                                        # def debug?
+          #{severity} >= @level                                          #   DEBUG >= @level
+        end                                                              # end
       EOT
     end
 
     # Set the auto-flush period. Set to true to flush after every log message,
     # to an integer to flush every N messages, or to false, nil, or zero to
@@ -96,16 +91,19 @@
         else raise ArgumentError, "Unrecognized auto_flushing period: #{period.inspect}"
         end
     end
 
     def flush
-      unless buffer.empty?
-        if @no_block
-          @log.write_nonblock(buffer.slice!(0..-1).join)
-        else
-          @log.write(buffer.slice!(0..-1).join)
+      @guard.synchronize do
+        unless buffer.empty?
+          old_buffer = buffer
+          @log.write(old_buffer.join)
         end
+
+        # Important to do this even if buffer was empty or else @buffer will
+        # accumulate empty arrays for each request where nothing was logged.
+        clear_buffer
       end
     end
 
     def close
       flush
@@ -114,8 +112,16 @@
     end
 
     protected
       def auto_flush
         flush if buffer.size >= @auto_flushing
+      end
+
+      def buffer
+        @buffer[Thread.current] ||= []
+      end
+
+      def clear_buffer
+        @buffer.delete(Thread.current)
       end
   end
 end