1  require 'thread'
   2 
   3  module ActiveSupport
   4    # Inspired by the buffered logger idea by Ezra
   5    class BufferedLogger
   6      module Severity
   7        DEBUG   = 0
   8        INFO    = 1
   9        WARN    = 2
  10        ERROR   = 3
  11        FATAL   = 4
  12        UNKNOWN = 5
  13      end
  14      include Severity
  15 
  16      MAX_BUFFER_SIZE = 1000
  17 
  18      ##
  19      # :singleton-method:
  20      # Set to false to disable the silencer
  21      cattr_accessor :silencer
  22      self.silencer = true
  23 
  24      # Silences the logger for the duration of the block.
  25      def silence(temporary_level = ERROR)
  26        if silencer
  27          begin
  28            old_logger_level, self.level = level, temporary_level
  29            yield self
  30          ensure
  31            self.level = old_logger_level
  32          end
  33        else
  34          yield self
  35        end
  36      end
  37 
  38      attr_accessor :level
  39      attr_reader :auto_flushing
  40 
  41      def initialize(log, level = DEBUG)
  42        @level         = level
  43        @buffer        = {}
  44        @auto_flushing = 1
  45        @guard = Mutex.new
  46 
  47        if log.respond_to?(:write)
  48          @log = log
  49        elsif File.exist?(log)
  50          @log = open(log, (File::WRONLY | File::APPEND))
  51          @log.sync = true
  52        else
  53          FileUtils.mkdir_p(File.dirname(log))
  54          @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
  55          @log.sync = true
  56          @log.write("# Logfile created on %s" % [Time.now.to_s])
  57        end
  58      end
  59 
  60      def add(severity, message = nil, progname = nil, &block)
  61        return if @level > severity
  62        message = (message || (block && block.call) || progname).to_s
  63        # If a newline is necessary then create a new message ending with a newline.
  64        # Ensures that the original message is not mutated.
  65        message = "#{message}\n" unless message[-1] == ?\n
  66        buffer << message
  67        auto_flush
  68        message
  69      end
  70 
  71      for severity in Severity.constants
  72        class_eval <<-EOT, __FILE__, __LINE__ + 1
  73          def #{severity.downcase}(message = nil, progname = nil, &block)  # def debug(message = nil, progname = nil, &block)
  74            add(#{severity}, message, progname, &block)                    #   add(DEBUG, message, progname, &block)
  75          end                                                              # end
  76                                                                           #
  77          def #{severity.downcase}?                                        # def debug?
  78            #{severity} >= @level                                          #   DEBUG >= @level
  79          end                                                              # end
  80        EOT
  81      end
  82 
  83      # Set the auto-flush period. Set to true to flush after every log message,
  84      # to an integer to flush every N messages, or to false, nil, or zero to
  85      # never auto-flush. If you turn auto-flushing off, be sure to regularly
  86      # flush the log yourself -- it will eat up memory until you do.
  87      def auto_flushing=(period)
  88        @auto_flushing =
  89          case period
  90          when true;                1
  91          when false, nil, 0;       MAX_BUFFER_SIZE
  92          when Integer;             period
  93          else raise ArgumentError, "Unrecognized auto_flushing period: #{period.inspect}"
  94          end
  95      end
  96 
  97      def flush
  98        @guard.synchronize do
  99          unless buffer.empty?
 100            old_buffer = buffer
 101            @log.write(old_buffer.join)
 102          end
 103 
 104          # Important to do this even if buffer was empty or else @buffer will
 105          # accumulate empty arrays for each request where nothing was logged.
 106          clear_buffer
 107        end
 108      end
 109 
 110      def close
 111        flush
 112        @log.close if @log.respond_to?(:close)
 113        @log = nil
 114      end
 115 
 116      protected
 117        def auto_flush
 118          flush if buffer.size >= @auto_flushing
 119        end
 120 
 121        def buffer
 122          @buffer[Thread.current] ||= []
 123        end
 124 
 125        def clear_buffer
 126          @buffer.delete(Thread.current)
 127        end
 128    end
 129  end