buffered_logger 0.0.2 → 0.1.0

data/README

@@ -0,0 +1,105 @@
+ABOUT
+-------------------------------------------------------------------------------
+The 'buffered_logger' gem is an extension to ActiveSupport::BufferedLogger which
+gives the the little logger some much needed formatting support. The actual
+logging work is still delegated to to active_support/buffered_logger.
+
+
+FEATURES
+-------------------------------------------------------------------------------
+- per thread indentation
+- per thread auto flush setting
+- temporary indentation blocks
+- per severity formatting
+- ansi color output formats
+
+
+USAGE
+-------------------------------------------------------------------------------
+# default initialization 
+l = BufferedLogger.new(STDOUT)
+
+# changing the severity level
+l.level = :warn
+l.level = 1
+
+# formatter constructor (initializes the master thread's formatters)
+l = BufferedLogger.new(STDOUT, :debug,  
+                       { :info  => "$green INFO: $white %s",
+                         :warn  => "$yellow WARNING: $white %s",
+                         :error => "$red ERROR: $white %s" } )
+
+# setting formatting after initialization
+l.info_formatter  = "$green INFO: $white %s",    
+l.warn_formatter  = "$yellow WARNING: $white %s"
+l.error_formatter = "$red ERROR: $white %s"
+
+# checking the current thread's formatting
+l.info_formatter.to_s
+l.warn_formatter.to_s
+...
+
+# checking the current thread's indentation
+l.padding.to_s
+
+# setting the current thread's indentation
+l.indent(4)                  # move cursor right 4 spaces
+l.indent(-2)                 # move cursor left 2 spaces
+l.indent(:reset)             # reset indentation
+
+# temporarily indenting using an indent block
+l.indent do
+  l.info 'some info'
+  ...
+  l.info 'some more info'
+end
+
+# setting auto_flushing
+l.auto_flushing = 2
+
+
+USAGE DETAILS
+-------------------------------------------------------------------------------
+* Severity Levels
+  - severity level is optional and defaults to :debug
+  - severity level can be provided as an Integer or Symbol
+      0 - DEBUG
+      1 - INFO
+      2 - WARN
+      3 - ERROR
+      4 - FATAL
+      5 - UNKNOWN
+
+* ActiveSupport::BufferedLogger
+  - native buffered_logger functionality is preserved
+    $ ActiveSupport::BufferedLogger.public_instance_methods(false)
+      => ["add", "info", "fatal?", "auto_flushing", "fatal", "silencer", "debug",
+          "info?", "warn?", "auto_flushing=", "silencer=", "level", "error?", "unknown",
+          "debug?", "flush", "level=", "open_log", "warn", "unknown?", "silence",
+          "error", "close"] 
+
+* ANSI Color
+  - colors are only supported when logging to STDOUT
+  - any ansi method may be used in a format string following a '$' symbol
+    $ Term::ANSIColor.instance_methods
+      => ["black", "on_yellow", "underscore", "rapid_blink", "white", "bold",
+          "yellow", "on_cyan", "strikethrough", "on_green", "uncolored", "blink",
+          "cyan", "reset", "green", "on_magenta", "clear", "concealed", "on_red",
+          "dark", "underline", "magenta", "red", "on_blue", "negative", "on_black",
+          "italic", "blue", "on_white"]
+
+* Indentation
+  - the padding is calculated on a per thread basis and each thread has an
+    indentation counter which is shared across all severity levels
+
+* Formatting
+  - formatters are set on a per thread/per severity basis, meaning that every
+    severity level for every thread allows for a custom formatter
+  - the formatter search order is as follows
+      1. current thread's formatter for specified severity
+      2. master thread's formatter for specified severity
+      3. master thread's default formatter
+    
+* Thread Buffering
+  - the auto_flushing setting is set per thread and each thread defaults to
+    the autoflush setting of the master thread unless explicitly configured

data/TODO

@@ -0,0 +1,3 @@
+TODO
+- tests for Buffering module
+- tests for Logger (include classic functionality)

data/lib/buffered_logger/buffering.rb

@@ -0,0 +1,66 @@
+module BufferedLogger::Buffering
+  MAX_BUFFER_SIZE = 1000
+
+  def initialize
+    @buffer        = Hash.new { |h,k| h[k] = [] }
+    @auto_flushing = BufferedLogger::ThreadHash.new
+    @auto_flushing[master_thread] = 1
+    @guard = Mutex.new
+    super()
+  end
+
+  def buffer_text
+    buffer.join('')
+  end
+
+  def auto_flushing
+    @auto_flushing[Thread.current] || @auto_flushing[master_thread]
+  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
+  # never auto-flush. If you turn auto-flushing off, be sure to regularly
+  # flush the log yourself -- it will eat up memory until you do.
+  def auto_flushing=(period)
+    @auto_flushing[Thread.current] =
+      case period
+      when true;                1
+      when false, nil, 0;       MAX_BUFFER_SIZE
+      when Integer;             period
+      else raise ArgumentError, "Unrecognized auto_flushing period: #{period.inspect}"
+      end
+  end
+
+  def flush
+    @guard.synchronize do
+      buffer.each do |content|
+        @log.write(content)
+      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
+    @log.close if @log.respond_to?(:close)
+    @log = nil
+  end
+
+private
+    
+  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

data/lib/buffered_logger/formatting.rb

@@ -0,0 +1,92 @@
+require 'term/ansicolor'
+
+module BufferedLogger::Formatting
+  DEFAULT_LEVEL = :default
+
+private
+
+  def initialize
+    @formatter = BufferedLogger::ThreadHash.new { |h,k| h[k] = {} }
+    super()
+  end
+
+  def formatter(severity = DEFAULT_LEVEL)
+    @formatter[Thread.current][severity] || @formatter[master_thread][severity] || default_formatter
+  end
+
+  def set_formatter(severity = DEFAULT_LEVEL, format = nil)
+    @formatter[Thread.current][severity] = BufferedLogger::Formatter.new(:format => format, :color => color?)
+  end
+
+  def default_formatter
+    @formatter[master_thread][DEFAULT_LEVEL] ||= BufferedLogger::Formatter.new(:color => color?)
+  end
+
+# magic format getters/setters
+
+  def method_missing(method, *args, &block)
+    case method.to_s
+    when /^(#{BufferedLogger::SEVERITY_LEVELS.join('|')})_formatter(=)?$/
+      $2 ? set_formatter($1.to_sym, args[0]) : formatter($1.to_sym)
+    else
+      super(method, *args, &block)
+    end
+  end
+
+end
+
+
+class BufferedLogger::Formatter
+  include ::Term::ANSIColor
+
+  FORMAT = "%s"
+  COLOR = true
+
+  def initialize(params = {})
+    @format = params[:format] || FORMAT
+    @color = params[:color] == false ? false : COLOR
+  end
+
+# format accessors
+
+  def to_s 
+    @format 
+  end
+
+  def format=(format)
+    @format = format.to_s 
+  end
+
+# color accessors
+
+  def color?
+    @color 
+  end
+
+  def toggle_color
+    @color = !@color
+  end
+
+# formatting
+
+  def %(message)
+    formatted_message = @format % message.to_s
+    color? ? parse_color(formatted_message) : formatted_message
+  end
+
+private
+
+  def parse_color(message)
+    color_methods = Term::ANSIColor.instance_methods
+    color_matcher = /#{color_methods.map {|m| "\\$#{m}\\s?"}.join('|')}/
+
+    strings = message.split(color_matcher)
+    colors = message.scan(color_matcher).map { |c| c[1..-1].strip }
+
+    colored_message = ''
+    strings[1..-1].each_with_index { |s,i| colored_message << self.send(colors[i], s) }
+    strings[0] + colored_message
+  end
+
+end
+

data/lib/buffered_logger/indentation.rb

@@ -0,0 +1,61 @@
+module BufferedLogger::Indentation
+# padding is set at the thread level
+
+  def initialize
+    @padding = BufferedLogger::ThreadHash.new { |h,k| h[k] = BufferedLogger::Padding.new }
+    super()
+  end
+
+  def padding
+    @padding[Thread.current]
+  end
+
+  def indent(level, &block)
+    if block_given?
+      padding.indent(level)
+      ret_val = block.call
+      padding.indent(-level)
+      return ret_val
+    else
+      padding.indent(level)
+    end
+  end
+
+end
+
+class BufferedLogger::Padding
+  PADDING_CHAR = ' '
+  PADDING_RESET= :reset
+  attr_reader :padding_char
+
+  def initialize(params = {})
+    @padding = ''
+    @padding_char = params[:padding_char] || PADDING_CHAR
+    indent(params[:indent] || 0)
+  end
+
+  def padding_char=(char)
+    @padding_char = char.to_s[0..1]
+  end
+
+  def to_s
+    @padding 
+  end
+
+  def indent(indent_level)
+    @padding = \
+      if indent_level == PADDING_RESET
+        ''
+      elsif indent_level > 0
+        @padding + (@padding_char * indent_level)
+      else
+        @padding[0..(-1+indent_level)]
+      end
+    indent_level
+  end
+
+  def %(message)
+    @padding + message.to_s 
+  end
+
+end

data/lib/buffered_logger/logger.rb

@@ -0,0 +1,114 @@
+require 'thread'
+require 'active_support/core_ext/class'
+
+class BufferedLogger
+  include Indentation
+  include Formatting
+  include Buffering
+
+  module Severity
+    DEBUG   = 0
+    INFO    = 1
+    WARN    = 2
+    ERROR   = 3
+    FATAL   = 4
+    UNKNOWN = 5
+  end
+  include Severity
+
+  SEVERITY_LEVELS = Severity.constants.map { |c| c.downcase.to_sym }.freeze
+  SEVERITY_MAP    = Severity.constants.inject({}) do |h,c| 
+                      h[c.downcase.to_sym] = Severity.const_get(c); h
+                    end.freeze
+
+
+  ##
+  # :singleton-method:
+  # Set to false to disable the silencer
+  cattr_accessor :silencer
+  self.silencer = true
+
+  attr_accessor :level
+  attr_reader :master_thread
+  private :master_thread
+
+  def initialize(log, level = DEBUG, params = {})
+    @master_thread = Thread.current
+    super()
+
+    @level = severity_to_const(level)
+    if log.respond_to?(:write)
+      @log = log
+    elsif File.exist?(log)
+      @log = open_log(log, (File::WRONLY | File::APPEND))
+    else
+      FileUtils.mkdir_p(File.dirname(log))
+      @log = open_log(log, (File::WRONLY | File::APPEND | File::CREAT))
+    end
+    params.each { |k,v| SEVERITY_LEVELS.include?(k) ? set_formatter(k, v) : next }
+  end
+
+  def open_log(log, mode)
+    open(log, mode).tap do |open_log|
+      open_log.set_encoding(Encoding::BINARY) if open_log.respond_to?(:set_encoding)
+      open_log.sync = 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.
+    message = "#{message}\n" unless message[-1] == ?\n
+    buffer << message
+    auto_flush
+    message
+  end
+
+  for severity in SEVERITY_LEVELS
+    class_eval <<-EOT, __FILE__, __LINE__ + 1
+      def #{severity}(message = nil, progname = nil, &block)
+        add(#{SEVERITY_MAP[severity]}, padding % (formatter(:#{severity}) % message.to_s), progname, &block)                  
+        nil
+      end                                                            
+
+      def #{severity}?                                      
+        #{SEVERITY_MAP[severity]} >= @level                                        
+      end                                                            
+    EOT
+  end
+
+  # Silences the logger for the duration of the block.
+  def silence(temporary_level = ERROR)
+    if silencer
+      begin
+        old_logger_level, self.level = level, temporary_level
+        yield self
+      ensure
+        self.level = old_logger_level
+      end
+    else
+      yield self
+    end
+  end
+
+private
+
+  def color?
+    @log == STDOUT
+  end
+
+  def severity_to_const(severity)
+    case severity
+    when Integer
+      severity
+    when Symbol
+      SEVERITY_MAP[severity]
+    else
+      severity.to_i
+    end
+  end
+
+end
+

data/lib/buffered_logger/thread_hash.rb

@@ -0,0 +1,12 @@
+class BufferedLogger::ThreadHash < Hash
+
+  def []=(k,v)
+    sweep if !include?(k) && k.is_a?(Thread)
+    super
+  end
+
+  def sweep
+    self.delete_if { |k,v| k.is_a?(Thread) && !k.alive? }
+  end
+
+end

data/lib/buffered_logger.rb

@@ -1,58 +1,7 @@
-require 'rubygems'
-require 'active_support/buffered_logger'
-require 'forwardable'
+class BufferedLogger; end
 
-class BufferedLogger
-  extend Forwardable
-
-  def_delegators :@logger, :level, :flush, :auto_flushing=
-
-  DEFAULT_FORMATTER = "%s"
-  DEFAULT_PADDING = ""
-  PADDING_CHAR = " "
-
-  def initialize(log_file, log_level, log_count = nil, log_size = nil)
-    @logger = ActiveSupport::BufferedLogger.new(log_file, log_level)
-    @padding, @formatter = {}, {}
-  end
-
-  def buffer
-    buf = @logger.send(:buffer)
-    buf && buf.join('')
-  end
-
-  # overwrite all the logging methods
-  class_eval do
-    [:debug, :info, :warn, :error, :fatal, :unknown].each do |method|
-      define_method(method) do |message|
-        @logger.send(method, (padding + formatter) % message.to_s)
-      end
-    end
-  end
-
-  def indent(indent_level)
-    @padding[Thread.current] = \
-      if indent_level == :reset
-        ""
-      elsif indent_level > 0
-        padding + (PADDING_CHAR * indent_level)
-      else
-        padding[0..(-1+indent_level)]
-      end
-  end
-
-  def formatter=(format)
-    @formatter[Thread.current] = format
-  end
-
-protected
-
-  def padding
-    @padding[Thread.current] ||= DEFAULT_PADDING
-  end
-  
-  def formatter
-    @formatter[Thread.current] ||= DEFAULT_FORMATTER
-  end
-
-end
+require 'buffered_logger/thread_hash'
+require 'buffered_logger/buffering'
+require 'buffered_logger/indentation'
+require 'buffered_logger/formatting'
+require 'buffered_logger/logger'

data/spec/buffering_spec.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe BufferedLogger do
+  before :each do
+    @f = StringIO.new
+    @l = BufferedLogger.new(@f)
+  end
+
+  describe 'buffering' do
+  end
+
+end

data/spec/formatting_spec.rb

@@ -0,0 +1,120 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe BufferedLogger::Formatter do
+  before :each do
+    @f = BufferedLogger::Formatter.new
+  end
+
+  describe 'initialization and accessors' do
+    it "should init a new formatter object" do
+      @f.should be_an_instance_of BufferedLogger::Formatter
+    end
+
+    it "should return the default format string" do
+      @f.to_s.should == '%s'
+    end
+
+    it "should set the format string" do
+      @f.format = '%d'
+      @f.to_s.should == '%d'
+    end
+
+    it 'should check if color is enabled by default' do
+      @f.color?.should be_true
+    end
+
+    it 'should toggle the color setting' do
+      @f.toggle_color
+      @f.color?.should be_false
+      @f.toggle_color
+      @f.color?.should be_true
+    end
+
+    it 'should construct a formatter object based on params' do
+      f = BufferedLogger::Formatter.new(:format => '%s%s%s', :color => false)
+      f.to_s.should == '%s%s%s'
+      f.color?.should be_false
+    end
+  end
+
+  describe 'formatting' do
+    it 'should parse color codes' do
+      s = "$blue blue $green green $red red"
+      @f.send(:parse_color, s).should == "\e[34mblue \e[0m\e[32mgreen \e[0m\e[31mred\e[0m"
+    end
+
+    it 'should format an input string' do
+      s = 'text'
+      (@f % s).should == 'text'
+      @f.format = '### %s ###'
+      (@f % s).should == '### text ###'
+      @f.format = '$blue ### $red %s $blue ###'
+      (@f % s).should == "\e[34m### \e[0m\e[31mtext \e[0m\e[34m###\e[0m"
+    end
+  end
+end
+
+describe BufferedLogger do
+  before :each do
+    @f = StringIO.new
+    @l = BufferedLogger.new(@f)
+  end
+
+  describe 'formatting' do
+    it 'should use appropriate formatting for each thread' do
+      @l.send(:set_formatter, :info, "$blue %s")
+      @l.info "oh"
+
+      t = Thread.new do
+        @l.send(:set_formatter, :info, "$red %s")
+        @l.info 'blah'
+      end; t.join
+
+      t = Thread.new do
+        @l.info 'hey'
+      end; t.join
+
+      @l.info "haha"
+
+      # colors are off so the keywords won't be parsed
+      @f.string.should == "$blue oh\n$red blah\n$blue hey\n$blue haha\n"
+    end
+
+    it 'should use appropriate formatting for each severity level' do
+      @l.send(:set_formatter, :error, "$red %s")
+      @l.send(:set_formatter, :info, "$blue %s")
+      @l.error 'error'
+      @l.info 'info'
+      @f.string.should == "$red error\n$blue info\n"
+    end
+
+    it 'should use the master thread formatter if one isnt set' do
+      @l.send(:set_formatter, :error, "$red %s")
+      @l.error 'test'
+
+      t = Thread.new do
+        @l.error 'blah'
+      end; t.join
+      @f.string.should == "$red test\n$red blah\n"
+    end
+
+    it 'should use the master thread default formatter if one isnt set' do
+      t_formatter = nil
+      t = Thread.new do
+        t_formatter = @l.send(:formatter, :info)
+      end; t.join
+
+      t_formatter.should == @l.send(:formatter, :info)
+      t_formatter.should == @l.send(:formatter, :error)
+    end
+
+    it 'should allow syntactic sugar to get/set formatters' do
+      BufferedLogger::SEVERITY_LEVELS.each do |s|
+        @l.send("#{s}_formatter=", "$green #{s}: $white %s")
+        @l.send("#{s}_formatter").to_s.should == "$green #{s}: $white %s"
+      end
+    end
+
+  end
+
+end

data/spec/indentation_spec.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe BufferedLogger::Padding do
+
+  before :each do
+    @p = BufferedLogger::Padding.new
+  end
+
+  describe 'initialization and accessors' do
+    it "should initialize a new padding object" do
+      @p.should be_an_instance_of BufferedLogger::Padding
+    end
+
+    it "should set padding character" do
+      @p.padding_char = '#'
+      @p.padding_char.should == '#'
+    end
+
+    it "should return the padding string" do
+      @p.to_s.should == ''
+    end
+
+    it "should construct pre-padded strings" do
+      p = BufferedLogger::Padding.new(:indent => 4, :padding_char => '#')
+      p.to_s.should == '####'
+    end
+  end
+
+  describe 'indentation' do
+    it "should indent padding a positive amount" do
+      @p.indent(2)
+      @p.to_s.should == '  '
+    end
+
+    it "should indent padding a negative amount" do
+      @p.indent(3)
+      @p.indent(-2)
+      @p.to_s.should == ' '
+    end
+
+    it "should reset padding indentation" do
+      @p.indent(10)
+      @p.indent(:reset)
+      @p.to_s.should == ''
+    end
+  end
+  
+  describe 'formatting' do
+    it "should apply padding to any input string" do
+      s = 'text'
+      @p.indent(4)
+      (@p % s).should == '    text'
+    end
+  end
+
+end
+
+
+describe BufferedLogger do
+  before :each do
+    @f = StringIO.new
+    @l = BufferedLogger.new(@f)
+  end
+
+  describe 'indentation' do
+    it 'should use appropriate indentation for each thread' do
+      @l.indent(4)
+      @l.info 'hello'
+
+      t = Thread.new do
+        @l.indent(2)
+        @l.info 'blah'
+      end; t.join
+
+      t = Thread.new do
+        @l.info 'hey'
+      end; t.join
+
+      @l.info 'hi'
+
+      @f.string.should == "    hello\n  blah\nhey\n    hi\n"
+    end
+
+    it 'should temporarily indent any logging in an indent block' do
+      @l.indent(4) do
+        @l.info 'blah'
+      end
+      @l.info 'blah'
+      @f.string.should == "    blah\nblah\n"
+    end
+  end
+end

data/spec/logger_spec.rb

@@ -0,0 +1,75 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require 'rubygems'
+require 'active_support/buffered_logger'
+
+describe BufferedLogger do
+  before :each do
+    @f = StringIO.new
+    @l = BufferedLogger.new(@f)
+  end
+
+  describe 'initialization and accessors' do
+    it 'should initialize a new logger object' do
+      @l.should be_an_instance_of BufferedLogger
+    end
+
+    it 'should initialize a logger object using a severity level symbol' do
+      l = BufferedLogger.new(@f, :info)
+      l.info  "info"
+      l.debug "debug"
+      l.warn  "warn"
+      @f.string.should == "info\nwarn\n"
+    end
+
+    it 'should support color when printing to STDOUT' do
+      l = BufferedLogger.new(STDOUT)
+      l.send(:color?).should == true
+    end
+
+    it 'should not support color when not printing to STDOUT' do
+      @l.send(:color?).should == false
+    end
+
+    it 'should autoset formatters during init' do
+      l = BufferedLogger.new(STDOUT, 0, {:info => '$green INFO: $white %s', :warn => '$yellow WARNING: $white %s', :error => '$red ERROR: $white %s'})
+      l.send(:formatter, :info).to_s.should == '$green INFO: $white %s'
+      l.send(:formatter, :warn).to_s.should == '$yellow WARNING: $white %s'
+      l.send(:formatter, :error).to_s.should == '$red ERROR: $white %s'
+    end
+  end
+
+  describe 'delegation and magic methods' do
+    it 'should maintain backwards compatibility with buffered_logger interface' do
+      delegated = ActiveSupport::BufferedLogger.public_instance_methods(false)
+      delegated.each { |method| @l.should respond_to(method) }
+    end
+
+    it 'should respond to magic methods' do
+      magic = BufferedLogger::SEVERITY_LEVELS
+      magic.each { |method| @l.should respond_to(method) }
+    end
+  end
+
+  describe 'logging' do
+    it 'should log to a IO object' do
+      severities = BufferedLogger::SEVERITY_LEVELS
+      severities.each do |s|
+        f = StringIO.new
+        l = BufferedLogger.new(f)
+        l.send(s, "#{s}_message")
+        f.string.should == "#{s}_message\n"
+      end
+    end
+
+    it 'should buffer unflushed statements' do
+      @l.auto_flushing = 0
+      @l.info 'test'
+      @l.info 'test2'
+      @l.buffer_text.should == "test\ntest2\n"
+      @f.string.should == ''
+      @l.flush
+      @f.string.should == "test\ntest2\n"
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$: << File.join(File.dirname(__FILE__), "../lib")
+require 'rspec'
+require 'stringio'
+require 'buffered_logger'

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 0
+  - 1
   - 0
-  - 2
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors: 
 - Alex Skryl
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-24 00:00:00 -05:00
+date: 2011-07-19 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,7 +32,7 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id001
-description: ActiveSupport's BufferedLogger with a few enhancements
+description: A thread safe logger with formatting extensions. Based on active_support/buffered_logger.
 email: rut216@gmail.com
 executables: []
 
@@ -41,7 +41,19 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/buffered_logger/buffering.rb
+- lib/buffered_logger/formatting.rb
+- lib/buffered_logger/indentation.rb
+- lib/buffered_logger/logger.rb
+- lib/buffered_logger/thread_hash.rb
 - lib/buffered_logger.rb
+- spec/buffering_spec.rb
+- spec/formatting_spec.rb
+- spec/indentation_spec.rb
+- spec/logger_spec.rb
+- spec/spec_helper.rb
+- README
+- TODO
 has_rdoc: true
 homepage: http://github.com/skryl
 licenses: []
@@ -75,6 +87,6 @@ rubyforge_project:
 rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: Extending ActiveSupport's BufferedLogger
+summary: A flexible, thread safe logger with custom formatting and ANSI color support
 test_files: []