birling 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+
+group :development do
+  gem "bundler"
+  gem "jeweler"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Scott Tadman, The Working Group.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,79 @@
+# birling
+
+A replacement for Logger that offers more robust handling of log rotation.
+
+The built-in logger supports log rotation on a daily, weekly or monthly basis,
+but not with more fine-grained control. Birling will allow rotation by hour,
+by day, or by an arbitrary amount of time expressed in seconds.
+
+Additionally, Birling will automatically remove old log files. These can be
+pruned off by age, by retaining a minimum number of them, or a combination of
+both.
+
+## Example
+
+The interface is very similar to the [built in logger](http://rubygems.org/gems/logger)
+facility that ships with Ruby:
+
+```ruby
+logger = Birling::Logger.new('test.log')
+
+logger.info("Application starting up.")
+logger.debug("application_init()")
+```
+
+A short-hand method is available:
+
+```ruby
+logger = Birling.open('test.log')
+```
+
+Log rotation parameters are quite flexible. For example, to retain a maximum
+of ten hourly logs:
+
+```ruby
+logger = Birling.open(
+  'test.log',
+  :period => :hourly,
+  :retain_count => 10
+)
+```
+
+Alternatively the retention period can be expressed in terms of time where
+log files that could have been created by this logger which are older than
+that period will be removed:
+
+```ruby
+logger = Birling.open(
+  'test.log',
+  :period => :hourly,
+  :retain_period => 10 * 3600
+)
+```
+
+The format of the resulting log-file can be adjusted by supplying a formatter.
+Several arguments passed to the formatter's `call` method, so a `lambda`, a
+`module` or an object instance could be used for this purpose.
+
+Example:
+
+```ruby
+logger = Birling.open(
+  'test.log',
+  :formatter => lambda { |severity, time, program, message| "#{time}> #{message}\n" }
+)
+```
+
+Note that the formatter is responsible for introducing any line-feeds into
+the resulting output stream. This gives the formatter complete control over
+what is written to the log.
+
+## Limitations
+
+The log rotation feature, for reasons that should be obvious, will not work
+on loggers that are created with an existing file-handle. For example, when
+using `STDOUT` the logger will not rotate.
+
+## Copyright
+
+Copyright (c) 2011-2012 Scott Tadman, The Working Group Inc.

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+require 'jeweler'
+
+Jeweler::Tasks.new do |gem|
+  gem.name = "birling"
+  gem.homepage = "http://github.com/twg/birling"
+  gem.license = "MIT"
+  gem.summary = %Q{Logger with simple log rotation system}
+  gem.description = %Q{Mostly drop-in replacement for Logger with a more robust log rotation facility}
+  gem.email = "github@tadman.ca"
+  gem.authors = [ "Scott Tadman" ]
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/birling/formatter.rb

@@ -0,0 +1,15 @@
+module Birling::Formatter
+  # == Constants ============================================================
+
+  TIME_FORMAT_DEFAULT = '%Y-%m-%d %H:%M:%S'.freeze
+
+  # == Module Methods =======================================================
+
+  def self.call(severity, time, program, message)
+    if (program)
+      "[#{time.strftime(TIME_FORMAT_DEFAULT)}] <#{program}> #{message}"
+    else
+      "[#{time.strftime(TIME_FORMAT_DEFAULT)}] #{message}"
+    end
+  end
+end

data/lib/birling/log.rb

@@ -0,0 +1,34 @@
+class Birling::Log < File
+  # == Constants ============================================================
+
+  # == Class Methods ========================================================
+
+  def self.open(log, mode = nil)
+    case (log)
+    when IO
+      yield(log) if (block_given?)
+      
+      log
+    when String
+      io = new(log, mode || 'a')
+    
+      yield(io) if (block_given?)
+    
+      io
+    end
+  end
+  
+  # == Instance Methods =====================================================
+  
+  def size
+    self.stat.size
+  end
+  
+  def create_time
+    self.stat.ctime
+  end
+  
+  def age(relative_to = nil)
+    (relative_to || Time.now) - self.stat.ctime
+  end
+end

data/lib/birling/logger.rb

@@ -0,0 +1,257 @@
+class Birling::Logger
+  # == Constants ============================================================
+  
+  # These level constants are the same as the syslog system utility
+  SEVERITY = {
+    :emergency => EMERGENCY = 0,
+    :alert => ALERT = 1,
+    :critical => CRITICAL = 2,
+    :error => ERROR = 3,
+    :warning => WARNING = 4,
+    :notice => NOTICE = 5,
+    :info => INFO = 6,
+    :debug => DEBUG = 7,
+    :unknown => UNKNOWN = 999
+  }.freeze
+  
+  DEFAULT_SEVERITY = UNKNOWN
+
+  SEVERITY_LABEL = SEVERITY.invert.freeze
+  
+  PATH_TIME_DEFAULT = {
+    :hourly => '%Y%m%d%H'.freeze,
+    :daily => '%Y%m%d'.freeze,
+    :default => '%s'.freeze
+  }.freeze
+  
+  # == Properties ===========================================================
+
+  attr_reader :severity
+  attr_accessor :formatter
+  attr_accessor :program
+  attr_accessor :time_source
+  attr_reader :path
+  attr_reader :path_format
+  attr_reader :path_time_format
+  attr_reader :current_path
+  attr_reader :retain_count
+  attr_reader :retain_period
+  attr_reader :period
+  attr_reader :rotation_time
+  
+  # == Class Methods ========================================================
+  
+  def self.severity(value)
+    case (value)
+    when Symbol
+      SEVERITY[value] or DEFAULT_SEVERITY
+    when String
+      SEVERITY[value.to_sym] or DEFAULT_SEVERITY
+    when Fixnum
+      SEVERITY_LABEL[value] and value or DEFAULT_SEVERITY
+    else
+      DEFAULT_SEVERITY
+    end
+  end
+  
+  # == Instance Methods =====================================================
+
+  def initialize(log, options = nil)
+    @period = (options and options[:period])
+    @severity = self.class.severity(options && options[:severity])
+    @retain_count = (options and options[:retain_count])
+    @retain_period = (options and options[:retain_period])
+    @formatter = (options and options[:formatter] or Birling::Formatter)
+    @program = (options and options[:program] or nil)
+    @time_source = (options and options[:time_source] or Time)
+    @path_format = (options and options[:path_format])
+
+    case (log)
+    when IO, StringIO
+      @log = log
+    when String
+      @path = log
+    end
+      
+    if (@path and @period)
+      @rotation_time = self.next_rotation_time
+      
+      @path_time_format = (PATH_TIME_DEFAULT[@period] or PATH_TIME_DEFAULT[:default])
+      
+      @path_format ||=
+        @path.sub(/\.(\w+)$/) do |s|
+          '.' + @path_time_format + '.' + $1
+        end
+    end
+    
+    if (@path and !@log)
+      self.log_open!
+    end
+  
+    yield(self) if (block_given?)
+  end
+  
+  def severity=(value)
+    @severity = self.class.severity(value)
+  end
+  
+  def can_rotate?
+    !!@path
+  end
+  
+  def size
+    @log and @log.respond_to
+  end
+  
+  def retain=(value)
+    @retain = value ? value.to_i : nil
+    
+    if (@retain_period and @retain_period <= 0)
+      @retain_period = nil
+    end
+    
+    @retain_period
+  end
+  
+  def log(level, message = nil, program = nil)
+    return unless (@log)
+    
+    level = self.class.severity(level)
+    program ||= @program
+
+    self.check_log_rotation!
+    
+    @log.write(@formatter.call(level, @time_source.now, program, message))
+  end
+  alias_method :add, :log
+
+  def <<(message)
+    return unless (@log)
+    
+    self.check_log_rotation!
+    
+    @log.write(message)
+  end
+  
+  SEVERITY.each do |name, level|
+    define_method(:"#{name}?") do
+      @severity >= level
+    end
+    
+    define_method(name) do |message = nil, program = nil|
+      return unless (@log and @severity >= level)
+      
+      program ||= @program
+      
+      if (!message and block_given?)
+        message = yield
+      end
+
+      self.check_log_rotation!
+
+      @log.write(@formatter.call(level, @time_source.now, program, message))
+    end
+  end
+
+  def close
+    return unless (@log)
+    
+    @log.close
+    @log = nil
+  end
+  
+  def opened?
+    !!@log
+  end
+
+  def closed?
+    !@log
+  end
+
+  def create_time
+    @log and @log.ctime
+  end
+  
+  def size
+    @log and @log.size
+  end
+   
+  def age(relative_to = nil)
+    (relative_to || @time_source.now) - @log.ctime
+  end
+  
+protected
+  def next_rotation_time
+    case (@period)
+    when Fixnum, Float
+      @time_source.now + @period
+    when :daily
+      Birling::Support.next_day(@time_source.now)
+    when :hourly
+      Birling::Support.next_hour(@time_source.now)
+    else
+      nil
+    end
+  end
+  
+  def prune_logs!
+    return unless (@path and (@retain_period or @retain_count))
+    
+    log_spec = @path.sub(/\.(\w+)$/, '*')
+    
+    logs = (Dir.glob(log_spec) - [ @path ]).collect do |p|
+      stat = File.stat(p)
+      create_time = (stat and stat.ctime or @time_source.now)
+      
+      [ p, create_time ]
+    end.sort_by do |r|
+      r[1] || @time_source.now
+    end
+    
+    if (@retain_period)
+      logs.reject! do |r|
+        if (Time.now - r[1] > @retain_period)
+          FileUtils.rm_f(r[0])
+        end
+      end
+    end
+    
+    if (@retain_count)
+      # The logs array is sorted from oldest to newest, so retaining the N
+      # newest entries entails stripping them off the end with pop.
+
+      logs.pop(@retain_count)
+      
+      FileUtils.rm_f(logs.collect { |r| r[0] })
+    end
+  end
+  
+  def check_log_rotation!
+    return unless (@rotation_time)
+    
+    if (@time_source.now >= @rotation_time)
+      self.log_open!
+      
+      @rotation_time = self.next_rotation_time
+    end
+  end
+
+  def log_open!
+    if (@path_format)
+      @current_path = @time_source.now.strftime(@path_format)
+      
+      @log = File.open(@current_path, 'a')
+      
+      if (File.exist?(@path) and File.symlink?(@path))
+        File.unlink(@path)
+        File.symlink(@path, @current_path)
+      end
+      
+      self.prune_logs!
+    else
+      @current_path = @path
+      
+      @log = File.open(@current_path, 'a')
+    end
+  end
+end

data/lib/birling/support.rb

@@ -0,0 +1,20 @@
+module Birling::Support
+  def next_day(time, time_source = nil)
+    (time_source || Time).local(
+      time.year,
+      time.month,
+      time.day,
+      23,
+      59,
+      59
+    ) + 1
+  end
+  
+  def next_hour(time, time_source = nil)
+    seconds_left = time.to_i % 3600
+    
+    time + (seconds_left > 0 ? seconds_left : 3600)
+  end
+    
+  extend self
+end

data/lib/birling.rb

@@ -0,0 +1,13 @@
+class Birling
+  # == Submodules ===========================================================
+  
+  autoload(:Formatter, 'birling/formatter')
+  autoload(:Logger, 'birling/logger')
+  autoload(:Support, 'birling/support')
+  
+  # == Module Methods =======================================================
+  
+  def self.open(path, options = nil)
+    Birling::Logger.new(path, options)
+  end
+end

data/test/helper.rb

@@ -0,0 +1,75 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'fileutils'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'birling'
+
+class Time::Warped < Time
+  def self.now
+    @now || super
+  end
+  
+  def self.now=(value)
+    @now = value
+  end
+end
+
+class Test::Unit::TestCase
+  def in_time_zone(zone)
+    tz = ENV['TZ']
+    
+    ENV['tz'] = zone
+    
+    yield if (block_given?)
+    
+  ensure
+    ENV['tz'] = tz
+  end
+  
+  def temp_path(name = nil)
+    name ||= begin
+      @temp_path_inc ||= 0
+
+      _name = '%05d.%05d.tmp' % [ @temp_path_inc, $$ ]
+      @temp_path_inc += 1
+      
+      _name
+    end
+    
+    case (name)
+    when Symbol
+      name = "#{name}.log"
+    end
+    
+    @temp_path ||= File.expand_path('../tmp', File.dirname(__FILE__))
+    
+    full_path = File.expand_path(name, @temp_path)
+    
+    FileUtils::mkdir_p(File.dirname(full_path))
+    
+    if (block_given?)
+      begin
+        yield(full_path)
+      ensure
+        remove_spec = File.expand_path('*', @temp_path)
+        
+        FileUtils.rm_f(Dir.glob(remove_spec))
+      end
+    end
+    
+    full_path
+  end
+end

data/test/test_birling.rb

@@ -0,0 +1,51 @@
+require File.expand_path('helper', File.dirname(__FILE__))
+
+class TestBirling < Test::Unit::TestCase
+  def test_module
+    assert Birling
+  end
+  
+  def test_open
+    _path = nil
+    
+    temp_path do |path|
+      _path = path
+      log = Birling.open(path)
+      
+      assert_equal Birling::Logger, log.class
+      
+      assert log
+      assert File.exist?(path)
+
+      assert log.opened?
+      assert !log.closed?
+      assert_equal 0, log.size
+      
+      assert log.debug?
+      
+      log.debug("Test")
+      
+      assert log.size > 0
+      
+      log.close
+      
+      assert !log.opened?
+      assert log.closed?
+    end
+    
+    assert !File.exist?(_path)
+  end
+  
+  def test_time_warped
+    _now = Time.now
+    
+    Time::Warped.now = _now
+
+    assert_not_equal Time.now, Time.now
+    assert_equal _now, Time::Warped.now
+    
+    Time::Warped.now = nil
+    
+    assert_not_equal _now, Time::Warped.now
+  end
+end

data/test/test_birling_logger.rb

@@ -0,0 +1,203 @@
+require File.expand_path('helper', File.dirname(__FILE__))
+
+class TestBirlingLogger < Test::Unit::TestCase
+  def test_defaults
+    temp_path do |path|
+      log = Birling::Logger.new(path)
+    
+      assert log
+
+      assert log.opened?
+      assert !log.closed?
+      assert_equal 0, log.size
+      assert Time.now >= log.create_time
+      
+      assert_equal Birling::Formatter, log.formatter
+      assert_equal Time, log.time_source
+      assert_equal nil, log.period
+    end
+  end
+  
+  def test_with_handle
+    s = StringIO.new
+    
+    log = Birling::Logger.new(s)
+    
+    assert log.opened?
+    
+    assert_equal 0, log.size
+  end
+  
+  def test_formatter
+    formatter_called = false
+    formatter = lambda do |severity, time, program, message|
+      formatter_called = true
+      message
+    end
+    
+    output = StringIO.new
+    log = Birling::Logger.new(output, :formatter => formatter)
+    
+    log.debug("Test")
+    
+    assert_equal true, formatter_called
+    
+    output.rewind
+    assert_equal "Test", output.read
+  end
+
+  def test_default_level
+    temp_path do |path|
+      log = Birling::Logger.new(path)
+    
+      assert log
+
+      assert log.opened?
+      assert !log.closed?
+      assert_equal 0, log.size
+      
+      assert log.debug?
+
+      log.debug("Test")
+      
+      current_size = log.size
+      assert current_size > 0
+    end
+  end
+  
+  def test_direct_write
+    output = StringIO.new
+  
+    log = Birling::Logger.new(output)
+    
+    log << "TEST"
+    
+    output.rewind
+    assert_equal "TEST", output.read
+  end
+  
+  def test_level_filter
+    output = StringIO.new
+  
+    log = Birling::Logger.new(
+      output,
+      :formatter => lambda { |s, t, p, m| "#{m}\n" },
+      :severity => :info
+    )
+    
+    log.debug("DEBUG")
+    log.info("INFO")
+    
+    output.rewind
+    assert_equal "INFO\n", output.read
+  end
+
+  def test_reopen
+    temp_path do |path|
+      log = Birling::Logger.new(path)
+
+      assert log.debug?
+
+      log.debug("Test")
+      
+      current_size = log.size
+      assert current_size > 0
+      
+      create_time = log.create_time
+      assert create_time <= Time.now
+      
+      log.close
+      
+      log = Birling::Logger.new(path)
+      
+      assert_equal current_size, log.size
+      assert_equal create_time, log.create_time
+    end
+  end
+  
+  def test_time_source
+    temp_path do |path|
+      frozen_time = Time.now
+      Time::Warped.now = frozen_time
+      
+      logger = Birling::Logger.new(path, :time_source => Time::Warped)
+      
+      assert_equal frozen_time, logger.time_source.now
+    end
+  end
+  
+  def test_cycling
+    temp_path(:cycle) do |path|
+      start = Time.now
+      Time::Warped.now = start
+      logger = Birling::Logger.new(path, :period => 1, :time_source => Time::Warped)
+      
+      assert_equal 1, logger.period
+      
+      current_path = logger.current_path
+      assert_equal '%s', logger.path_time_format
+    
+      logger.debug("Test")
+      
+      Time::Warped.now += 1
+      
+      logger.debug("Test")
+
+      assert_not_equal current_path, logger.current_path
+      
+      current_path = logger.current_path
+
+      Time::Warped.now += 1
+      
+      logger.debug("Test")
+      
+      assert_not_equal current_path, logger.current_path
+    end
+  end
+  
+  def test_retain_count
+    temp_path(:cycle) do |path|
+      start = Time.now
+      Time::Warped.now = start
+      
+      retain_count = 10
+
+      logger = Birling::Logger.new(
+        path,
+        :period => 1,
+        :time_source => Time::Warped,
+        :retain_count => retain_count
+      )
+
+      (retain_count + 5).times do |n|
+        logger.debug("Test")
+        Time::Warped.now += 1
+        logger.debug("Test")
+      end
+      
+      assert_equal retain_count, Dir.glob(logger.path_format % '*').length
+    end
+  end
+
+  def test_retain_period
+    temp_path(:cycle) do |path|
+      retain_period = 3
+      
+      logger = Birling::Logger.new(
+        path,
+        :period => 1,
+        :retain_period => retain_period
+      )
+
+      finish = Time.now + retain_period + 5
+
+      while (Time.now < finish)
+        logger.debug("Test")
+        Time::Warped.now += 1
+        logger.debug("Test")
+      end
+      
+      assert_equal retain_period + 1, Dir.glob(logger.path_format % '*').length
+    end
+  end
+end

data/test/test_birling_support.rb

@@ -0,0 +1,54 @@
+require File.expand_path('helper', File.dirname(__FILE__))
+
+class TestBirlingSupport < Test::Unit::TestCase
+  def test_next_day_on_dst_flip
+    in_time_zone('EST5EDT') do
+      time = Time.new(2012, 11, 4)
+      
+      assert_equal time.day, (time + 86400).day
+      
+      next_day = Birling::Support.next_day(time)
+      
+      assert_equal 2012, next_day.year
+      assert_equal 11, next_day.month
+      assert_equal 5, next_day.day
+      assert_equal 0, next_day.hour
+      assert_equal 0, next_day.min
+      assert_equal 0, next_day.sec
+    end
+  end
+
+  def test_hour_day_on_dst_flip
+    in_time_zone('EST5EDT') do
+      time = Time.new(2012, 11, 4, 0, 59, 59) + 1
+      
+      assert_equal time.hour, (time + 3600).hour
+      
+      next_hour = Birling::Support.next_hour(time)
+      
+      assert_equal 2012, next_hour.year
+      assert_equal 11, next_hour.month
+      assert_equal 4, next_hour.day
+      assert_equal 1, next_hour.hour
+      assert_equal 0, next_hour.min
+      assert_equal 0, next_hour.sec
+      
+      assert_equal 3600, next_hour - time
+    end
+  end
+
+  def test_next_day_at_year_end
+    in_time_zone('EST5EDT') do
+      time = Time.new(2012, 12, 31)
+      
+      next_day = Birling::Support.next_day(time)
+      
+      assert_equal 2013, next_day.year
+      assert_equal 1, next_day.month
+      assert_equal 1, next_day.day
+      assert_equal 0, next_day.hour
+      assert_equal 0, next_day.min
+      assert_equal 0, next_day.sec
+    end
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: birling
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Scott Tadman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Mostly drop-in replacement for Logger with a more robust log rotation
+  facility
+email: github@tadman.ca
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/birling.rb
+- lib/birling/formatter.rb
+- lib/birling/log.rb
+- lib/birling/logger.rb
+- lib/birling/support.rb
+- test/helper.rb
+- test/test_birling.rb
+- test/test_birling_logger.rb
+- test/test_birling_support.rb
+homepage: http://github.com/twg/birling
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Logger with simple log rotation system
+test_files: []