threadedlogger 1.1.0 → 1.2.0

data/History.txt

@@ -1,5 +1,10 @@
 # History for ThreadedLogger
 
+## v1.2.0
+
+* Allow multiple loggers to be instantiated as subclasses
+* add ::clear and ::clear_all class methods
+
 ## v1.1.0
 
 * Dynamically generate logging methods

data/Manifest.txt

@@ -4,8 +4,13 @@ README.txt
 LICENSE.txt
 Rakefile
 lib/threadedlogger.rb
+lib/threadedlogger/core.rb
+lib/threadedlogger/version.rb
+lib/threadedlogger/logger.rb
 test/minitest_helper.rb
 test/test_logging.rb
 test/test_methods.rb
 test/test_threadedlogger.rb
+test/test_shutdown.rb
+test/test_clear.rb
 threadedlogger.gemspec

data/README.txt

@@ -13,24 +13,46 @@ to ensure that multiple threads don't step on each other's toes.
 
 ## SYNOPSIS:
 
-```ruby
-require 'threadedlogger'
-
-log = ThreadedLogger.instance(logfname, 'daily', 'debug')
-log.info('START')
-...
-log.debug('super important stuff')
-...
-log.info("STOP")
-log.shutdown
-
-log2 = ThreadedLogger.instance(logfname, 'daily', 'debug', proc { |l| "prefix: #{l}" })
-```
-
-ThreadedLogger has one and only one instance, accessed via the ::instance
+    require 'threadedlogger'
+
+    log = ThreadedLogger.instance(logfname, 'daily', 'debug')
+    log.info('START')
+    ...
+    log.debug('super important stuff')
+    ...
+    log.info("STOP")
+    log.shutdown
+
+or if you have multiple loggers
+
+    require 'threadedlogger'
+
+    class Log1 < ThreadedLogger
+    end
+
+    class Log2 < ThreadedLogger
+    end
+
+    log1 = Log1.instance(logfname1, 'daily', 'debug')
+    log2 = Log2.instance(logfname2, 'daily', 'debug')
+    log1.info('START')
+    ...
+    log1.debug('super important stuff')
+    log2.info('something that only goes to the second log')
+    ...
+    log1.info("STOP")
+    log2.shutdown
+    log1.shutdown
+
+ThreadedLogger can be subclassed if you need to have multiple logs in a
+program.  Each subclass has one logger instance, accessed via the ::instance
 class method.  You can only provide arguments the first time - trying to
 're-construct' the object will throw an ArgumentError.
 
+If you only need one logger, you can just use ThreadedLogger without
+subclassing it.  Instances are stored keyed on class name, and the base
+class is a valid key.
+
 Under the covers, the dedicated thread uses the standard Ruby Logger
 library.  Refer to [Logger](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/logger/rdoc/Logger.html)
 for further detail.
@@ -46,9 +68,21 @@ instance method before your program exits.  On a clean shutdown this should
 happen automatically, but if you exit in a funky way it might not capture
 the last message.
 
+The catalog of instances can be cleared using the ::clear and ::clear_all
+class methods.  Each takes an optional boolean argument indicating whether
+::shutdown should be called on any active loggers before clearing them.
+
 This library also overrides Logger.LogDevice.add_log_header to prevent it
 from putting a header line at the top of a logfile when it is first opened.
 
+## CONSTRUCTION THREAD SAFETY
+
+ThreadedLogger does not mutex construction, as the typical use case is for
+the logger to be initialized for the first time outside of threaded code. 
+If you call the constructor for the first time from threaded code, you will
+need to protect ::instance with some kind of synchronization to avoid a race
+condition.
+
 ## LICENSE:
 
 The MIT License (MIT)

data/Rakefile

@@ -14,5 +14,5 @@ Rake::TestTask.new("unit_tests") { |t|
     t.libs.push 'test'
     t.pattern = 'test/test_*.rb'
     t.verbose = true
-    t.warning = true
+    t.warning = false
 }

data/lib/threadedlogger.rb

@@ -1,133 +1,3 @@
-require 'thread'
-require 'logger'
-
-class ThreadedLogger
-
-    VERSION = '1.1.0'
-    
-    @@instance = nil
-
-    LOGLEVELS = {
-        'debug' => Logger::DEBUG,
-        'info' => Logger::INFO,
-        'warn' => Logger::WARN,
-        'error' => Logger::ERROR,
-        'fatal' => Logger::FATAL,
-    }
-
-    private_class_method :new
-
-    # create the logging methods
-    LOGLEVELS.each do |k,v|
-        log_method = k.to_sym
-        test_method = "#{k}?".to_sym
-        define_method(log_method) { |msg=nil|
-            enqueue(v, msg)
-        }
-        define_method(test_method) {
-            @log.send(test_method)
-        }
-    end
-
-    def ThreadedLogger.instance(*args)
-
-        if @@instance.nil?
-            @@instance = new(*args)
-        else
-            if ! args.empty?
-                raise ArgumentError, "instance already constructed"
-            end
-        end
-
-        return @@instance
-
-    end
-
-    def initialize(file, rotation = 'daily', level = 'info', formatter = nil)
-
-        if file.nil?
-            raise ArgumentError, "log file name is required"
-        end
-
-        # create a logger
-        @log = Logger.new(file, rotation)
-
-        # set the min threshold
-        send(:level=, level)
-
-        # apply a formatter if one was given
-        if ! formatter.nil?
-            @log.formatter = formatter
-        end
-
-        # set up a queue and spawn a thread to do the logging
-        @queue = Queue.new
-        @shutdown = nil
-        @t = Thread.new { runlogger }
-      
-    end
-    
-    def level=(level)
-        if LOGLEVELS.has_key?(level)
-            @log.level = LOGLEVELS[level]
-        else
-            raise ArgumentError, "invalid log level #{level}"
-        end
-    end
-    
-    def shutdown
-
-        # stops new messages from being enqueued and tells thread
-        # to drain what's in the queue
-        @shutdown = true
-        @t.join
-
-    end
-
-    def enqueue(severity, msg=nil)
-
-        # don't enqueue if we're in shutdown
-        if( @shutdown )
-            return
-        end
-
-        # put the message on the queue
-        @queue.push( [severity, msg] )
-
-    end
-
-    private
-
-    def runlogger
-
-        # do blocking pops off the queue until the shutdown flag is set
-        while @shutdown.nil?
-            msg = @queue.pop(false)
-            @log.add(msg[0], msg[1])
-        end
-
-        # pop anything left on the queue off
-        while ! @queue.empty?
-            msg = @queue.pop(true)
-            @log.add(msg[0], msg[1])
-        end
-
-    end
-
-end
-
-# supress the "Logfile created at" header line that logger.rb provides
-class Logger
-
-    private
-
-    class LogDevice
-
-        private
-
-        def add_log_header(file)
-        end
-
-    end
-
-end
+require 'threadedlogger/version'
+require 'threadedlogger/core'
+require 'threadedlogger/logger'

data/lib/threadedlogger/core.rb

@@ -0,0 +1,138 @@
+require 'thread'
+require 'logger'
+
+class ThreadedLogger
+
+    LOGLEVELS = {
+        'debug' => Logger::DEBUG,
+        'info' => Logger::INFO,
+        'warn' => Logger::WARN,
+        'error' => Logger::ERROR,
+        'fatal' => Logger::FATAL,
+    }
+    
+    @@instances = nil
+
+    private_class_method :new
+
+    # create the logging methods
+    LOGLEVELS.each do |k,v|
+        log_method = k.to_sym
+        test_method = "#{k}?".to_sym
+        define_method(log_method) { |msg=nil|
+            enqueue(v, msg)
+        }
+        define_method(test_method) {
+            @log.send(test_method)
+        }
+    end
+
+    def self.instance(*args)
+        if @@instances[self].nil?
+            @@instances[self] = new(*args)
+        else
+            if ! args.empty?
+                raise ArgumentError, "instance for #{self} already constructed"
+            end
+        end
+        return @@instances[self]
+    end
+
+    def self.clear(shutdown = false)
+        if shutdown and ! @@instances[self].nil?
+            @@instances[self].shutdown
+        end
+        @@instances[self] = nil
+    end
+
+    def self.clear_all(shutdown = false)
+        if shutdown and ! @@instances.nil?
+            @@instances.each_value do |obj|
+                if ! obj.nil?
+                    obj.shutdown
+                end
+            end
+        end
+        @@instances = Hash.new
+    end
+
+    def initialize(file, rotation = 'daily', level = 'info', formatter = nil)
+        if file.nil?
+            raise ArgumentError, "log file name is required"
+        end
+
+        # create a logger
+        @log = Logger.new(file, rotation)
+
+        # set the min threshold
+        send(:level=, level)
+
+        # apply a formatter if one was given
+        if ! formatter.nil?
+            @log.formatter = formatter
+        end
+
+        # set up a queue and spawn a thread to do the logging
+        @queue = Queue.new
+        @shutdown = false
+        @t = Thread.new {
+            runlogger
+        }
+    end
+    
+    def level=(level)
+        if LOGLEVELS.has_key?(level)
+            @log.level = LOGLEVELS[level]
+        else
+            raise ArgumentError, "invalid log level #{level}"
+        end
+    end
+    
+    def shutdown
+
+        # stops new messages from being enqueued and tells thread
+        # to drain what's in the queue
+        if ! @shutdown
+            @shutdown = true
+            @queue.push(nil)
+            @t.join
+            @t = nil
+        end
+
+    end
+
+    def enqueue(severity, msg=nil)
+        # don't enqueue if we're in shutdown
+        if( @shutdown )
+            return
+        end
+
+        # put the message on the queue
+        @queue.push( [severity, msg] )
+    end
+
+    private
+
+    def runlogger
+        # do blocking pops off the queue until the shutdown flag is set
+        while ! @shutdown
+            msg = @queue.pop(false)
+            if ! msg.nil?
+                @log.add(msg[0], msg[1])
+            end
+        end
+
+        # pop anything left on the queue off
+        while ! @queue.empty?
+            msg = @queue.pop(true)
+            if ! msg.nil?
+                @log.add(msg[0], msg[1])
+            end
+        end
+    end
+    
+    # create catalog of per-subclass instances
+    self.clear_all
+
+end
+

data/lib/threadedlogger/logger.rb

@@ -0,0 +1,15 @@
+# Monkey patch Logger to supress the "Logfile created at" header line
+class Logger
+
+    private
+
+    class LogDevice
+
+        private
+
+        def add_log_header(file)
+        end
+
+    end
+
+end

data/lib/threadedlogger/version.rb

@@ -0,0 +1,5 @@
+class ThreadedLogger
+
+    VERSION = '1.2.0'
+
+end

data/test/minitest_helper.rb

@@ -1,5 +1,21 @@
 require 'simplecov'
+require 'simplecov-console'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    SimpleCov::Formatter::Console,
+]
 SimpleCov.start do
     add_filter '/vendor/'
     add_filter '/test/'
 end
+
+require 'minitest/autorun'
+require 'minitest/debugger' if ENV['DEBUG']
+require 'threadedlogger'
+
+class ThreadedLoggerTest < Minitest::Test
+    def teardown
+        ThreadedLogger.clear_all(true)
+    end
+end

data/test/test_clear.rb

@@ -0,0 +1,11 @@
+require 'minitest_helper'
+require 'threadedlogger'
+
+class TestClear < ThreadedLoggerTest
+    def test_clear_without_shutdown
+        logger = ThreadedLogger.instance('test/foo.log', 'daily')
+        ThreadedLogger.clear
+        logger = ThreadedLogger.instance('test/foo.log', 'daily')
+        ThreadedLogger.clear(true)
+    end
+end

data/test/test_inheritable.rb

@@ -0,0 +1,67 @@
+require 'minitest_helper'
+require 'threadedlogger'
+
+class OurLog1 < ThreadedLogger
+end
+
+class OurLog2 < ThreadedLogger
+end
+
+class TestInheritable < ThreadedLoggerTest
+    def test_construct_subclass
+        logger = OurLog1.instance('test/foo.log', 'daily')
+        assert_instance_of(OurLog1, logger)
+        logger.info 'foo'
+        File.exists?('test/foo.log')
+        logger.shutdown
+    end
+    def test_construct_two_subclasses
+        logger1 = OurLog1.instance('test/foo.log', 'daily')
+        logger2 = OurLog2.instance('test/bar.log', 'daily')
+        assert_instance_of(OurLog1, logger1)
+        assert_instance_of(OurLog2, logger2)
+        logger1.info 'foo'
+        logger2.info 'bar'
+        File.exists?('test/foo.log')
+        File.exists?('test/bar.log')
+        logger1.shutdown
+        logger2.shutdown
+    end
+    def test_reconstruct_subclass
+        logger1 = OurLog1.instance('test/foo.log', 'daily')
+        logger2 = OurLog2.instance('test/bar.log', 'daily')
+        assert_instance_of(OurLog1, logger1)
+        assert_instance_of(OurLog2, logger2)
+        assert_raises(ArgumentError) {
+            OurLog1.instance('test/foo.log', 'daily')
+        }
+        assert_raises(ArgumentError) {
+            OurLog2.instance('test/bar.log', 'daily')
+        }
+    end
+    def test_clear
+        logger1 = OurLog1.instance('test/foo.log', 'daily')
+        logger2 = OurLog2.instance('test/bar.log', 'daily')
+        assert_instance_of(OurLog1, logger1)
+        assert_instance_of(OurLog2, logger2)
+        assert_raises(ArgumentError) {
+            OurLog1.instance('test/foo.log', 'daily')
+        }
+        OurLog1.clear
+        logger2b = OurLog2.instance
+        assert_instance_of(OurLog2, logger2b)
+        assert_equal logger2b, logger2
+        logger1 = OurLog1.instance('test/foo.log', 'daily')
+        assert_instance_of(OurLog1, logger1)
+    end
+    def test_clear_all
+        logger1 = OurLog1.instance('test/foo.log', 'daily')
+        assert_instance_of(OurLog1, logger1)
+        assert_raises(ArgumentError) {
+            OurLog1.instance('test/foo.log', 'daily')
+        }
+        ThreadedLogger.clear_all
+        logger1 = OurLog1.instance('test/foo.log', 'daily')
+        assert_instance_of(OurLog1, logger1)
+    end
+end

data/test/test_logging.rb

@@ -1,25 +1,11 @@
 require 'minitest_helper'
-require 'minitest/autorun'
 require 'threadedlogger'
-require 'fakefs'
 
-class ThreadedLogger
-    def ThreadedLogger.clear
-        if ! @@instance.nil?
-            @@instance.shutdown
-            @@instance = nil
-        end
-    end
-end
-
-class TestLogging < Minitest::Test
-    def setup
-        ThreadedLogger.clear
-    end
+class TestLogging < ThreadedLoggerTest
     def test_logging
-        logger = ThreadedLogger.instance('foo.log', 'daily')
+        logger = ThreadedLogger.instance('test/foo.log', 'daily')
         logger.info 'foo'
-        File.exists?('foo.log')
+        File.exists?('test/foo.log')
         logger.shutdown
     end
 end

data/test/test_methods.rb

@@ -1,23 +1,8 @@
 require 'minitest_helper'
-require 'minitest/autorun'
-require 'threadedlogger'
-require 'fakefs'
 
-class ThreadedLogger
-    def ThreadedLogger.clear
-        if ! @@instance.nil?
-            @@instance.shutdown
-            @@instance = nil
-        end
-    end
-end
-
-class TestMethods < Minitest::Test
-    def setup
-        ThreadedLogger.clear
-    end
+class TestMethods < ThreadedLoggerTest
     def test_levels
-        logger = ThreadedLogger.instance('test/example.log', 'daily')
+        logger = ThreadedLogger.instance('test/foo.log', 'daily')
         assert_instance_of ThreadedLogger, logger, "constructor works with 2 args"
         %w(debug info warn error fatal).each do |level|
             assert_respond_to(logger, level.to_sym, "logger responds to level #{level}")
@@ -27,14 +12,14 @@ class TestMethods < Minitest::Test
         }
     end
     def test_level_predicates
-        logger = ThreadedLogger.instance('test/example.log', 'daily', 'info')
+        logger = ThreadedLogger.instance('test/foo.log', 'daily', 'info')
         assert_instance_of ThreadedLogger, logger, "constructor works with 3 args"
         %w(debug info warn error fatal).each do |level|
             assert_respond_to(logger, "#{level}?".to_sym, "logger responds to predicate #{level}?")
         end
     end
     def test_setlevel
-        logger = ThreadedLogger.instance('test/example.log', 'daily', 'info')
+        logger = ThreadedLogger.instance('test/foo.log', 'daily', 'info')
         assert_instance_of ThreadedLogger, logger, "constructor works with 3 args"
         assert_equal(false, logger.debug?, 'debug is not on when contstructed at level info')
         logger.level = 'debug'

data/test/test_shutdown.rb

@@ -0,0 +1,10 @@
+require 'minitest_helper'
+require 'threadedlogger'
+
+class TestShutdown < ThreadedLoggerTest
+    def test_enqueue_after_shutdown
+        logger = ThreadedLogger.instance('test/foo.log', 'daily')
+        logger.shutdown
+        logger.info('foo')
+    end
+end

data/test/test_threadedlogger.rb

@@ -1,31 +1,16 @@
 require 'minitest_helper'
-require 'minitest/autorun'
-require 'threadedlogger'
-require 'fakefs'
 
-class ThreadedLogger
-    def ThreadedLogger.clear
-        if ! @@instance.nil?
-            @@instance.shutdown
-            @@instance = nil
-        end
-    end
-end
-
-class TestThreadedLogger < Minitest::Test
-    def setup
-        ThreadedLogger.clear
-    end
+class TestThreadedLogger < ThreadedLoggerTest
     def test_constructor
-        logger = ThreadedLogger.instance('test/example.log', 'daily')
+        logger = ThreadedLogger.instance('test/foo.log', 'daily')
         assert_instance_of ThreadedLogger, logger, "constructor works with 2 args"
     end
     def test_constructor_with_level
-        logger = ThreadedLogger.instance('test/example.log', 'daily', 'info')
+        logger = ThreadedLogger.instance('test/foo.log', 'daily', 'info')
         assert_instance_of ThreadedLogger, logger, "constructor works with 3 args"
     end
     def test_constructor_with_level_and_formatter
-        logger = ThreadedLogger.instance('test/example.log', 'daily', 'info', proc { |l| l } )
+        logger = ThreadedLogger.instance('test/foo.log', 'daily', 'info', proc { |l| l } )
         assert_instance_of ThreadedLogger, logger, "constructor works with 4 args"
     end
     def test_constructor_noargs
@@ -34,14 +19,14 @@ class TestThreadedLogger < Minitest::Test
         end
     end
     def test_singleton
-        loggera = ThreadedLogger.instance('test/example.log')
+        loggera = ThreadedLogger.instance('test/foo.log')
         loggerb = ThreadedLogger.instance
         assert_same loggera, loggerb, "two instances are the same object"
     end
     def test_construct_twice
         assert_raises ArgumentError, "cannot call instance a second time with args" do
-            ThreadedLogger.instance('test/example.log')
-            ThreadedLogger.instance('test/example2.log')
+            ThreadedLogger.instance('test/foo.log')
+            ThreadedLogger.instance('test/bar.log')
         end
     end
 end

data/threadedlogger.gemspec

@@ -4,7 +4,6 @@ require 'threadedlogger'
 Gem::Specification.new do |s|
     s.name          = 'threadedlogger'
     s.version       = ThreadedLogger::VERSION
-    s.date          = '2013-03-23'
     s.summary       = 'Simple logging library with a dedicated logging thread'
     s.homepage      = 'https://github.com/jf647/ThreadedLogger'
     s.authors       = ['James FitzGibbon']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: threadedlogger
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -63,11 +63,17 @@ files:
 - LICENSE.txt
 - Rakefile
 - lib/threadedlogger.rb
+- lib/threadedlogger/core.rb
+- lib/threadedlogger/version.rb
+- lib/threadedlogger/logger.rb
 - test/minitest_helper.rb
 - test/test_logging.rb
 - test/test_methods.rb
 - test/test_threadedlogger.rb
+- test/test_shutdown.rb
+- test/test_clear.rb
 - threadedlogger.gemspec
+- test/test_inheritable.rb
 - .gemtest
 homepage: https://github.com/jf647/ThreadedLogger
 licenses:
@@ -86,7 +92,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1670757235924190297
+      hash: -484491560591714406
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -95,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1670757235924190297
+      hash: -484491560591714406
 requirements: []
 rubyforge_project: threadedlogger
 rubygems_version: 1.8.23
@@ -104,6 +110,9 @@ specification_version: 3
 summary: ThreadedLogger runs a dedicated logging thread around Ruby's Logger library
   to ensure that multiple threads don't step on each other's toes.
 test_files:
+- test/test_clear.rb
+- test/test_inheritable.rb
 - test/test_logging.rb
 - test/test_methods.rb
+- test/test_shutdown.rb
 - test/test_threadedlogger.rb