lumber 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46565c6578428e0fd2b235b3c342958c1bdd2ca2
-  data.tar.gz: f6d4b6262295e7e8f7eb9ffac68ae180ae9329c0
+  metadata.gz: 39acf970ab7a4cba53d738adec952246cdb7e36d
+  data.tar.gz: 84b4141111b47aafb6a133913f4d118c6ba7bacf
 SHA512:
-  metadata.gz: 252efef13b42f54c839d9b9b20908df2e6902a9b657c9452283e9dde81600ce63ebb95f9d9f2878b65eead7e2d6da8279761e00bdfb9a63a7ffba5117dec48f8
-  data.tar.gz: 3110b279693bea1ad2a1b522aff0c9c9ab6c57090e1a1c6b3f44adda84748af326f44a84f994144d9e296c5d05888bd621d8feed5062f5cc8108e11b4d848629
+  metadata.gz: d59e9dea06165dea70ad6d4f49e7e271065452c8c58c7656fbcac166dc20d792f2033219416941abe28e2274308945f6b88fea7c1c9c8643b1362397681dc1e1
+  data.tar.gz: 6a2a398953b7f856988abcf74950d3e50086647b3d1b8e4ec95aadb2a93e3548f15d1e889306ab5afa1a0b44956ea5f62fd4d105320aa85fe338b763d3511397

data/CHANGELOG

@@ -1,3 +1,15 @@
+1.1.0 (11/10/2013)
+------------------
+
+Make loggers get created lazily, refactoring to support this behavior and (hopefully) make the code more understandable <8c2bd7b> [Matt Conway]
+disable coveralls for jruby <9a1ff9b> [Matt Conway]
+fix jruby <71dc96f> [Matt Conway]
+fix rails generator <164c9ed> [Matt Conway]
+fix tests for move of log4r.yml in generators <319fc3d> [Matt Conway]
+more readable <20a9666> [Matt Conway]
+refactor a bit to add more thread safety <3712ee1> [Matt Conway]
+try and fix travis error <7a4e59e> [Matt Conway]
+
 1.0.3 (10/11/2013)
 ------------------
 

data/lib/generators/lumber/lumber_generator.rb

@@ -0,0 +1,10 @@
+
+class LumberGenerator < Rails::Generators::Base
+  source_root File.expand_path("../templates", __FILE__)
+
+  desc "This generator adds a log4r.yml in config/"
+  def create_log4r_yml
+    copy_file "log4r.yml", "config/log4r.yml"
+  end
+
+end

data/lib/lumber.rb

@@ -1,8 +1,11 @@
 $:.unshift(File.dirname(__FILE__))
 
 # before config block
+require "monitor"
 require "lumber/lumber"
+require "lumber/inheritance_registry"
 require "lumber/logger_support"
+require "lumber/prevent_rails_override"
 require "lumber/log4r"
 require "lumber/level_util"
 require "lumber/json_formatter"

data/lib/lumber/inheritance_registry.rb

@@ -0,0 +1,85 @@
+module Lumber
+
+  module InheritanceRegistry
+    extend MonitorMixin
+    extend self
+
+    @mapping = {}
+
+    def []=(class_name, logger_fullname)
+      synchronize do
+        @mapping[class_name] = logger_fullname
+      end
+    end
+
+    def [](class_name)
+      synchronize do
+        @mapping[class_name]
+      end
+    end
+
+    def clear
+      synchronize do
+        @mapping.clear
+      end
+    end
+
+    def find_registered_logger(clazz)
+      synchronize do
+        return nil unless clazz
+        logger_name = self[clazz.name]
+        logger_name || find_registered_logger(clazz.superclass)
+      end
+    end
+
+    def remove_inheritance_handler
+      synchronize do
+
+        return unless defined?(Object.inherited_with_lumber_registry)
+
+        Object.class_eval do
+          class << self
+            remove_method :inherited_with_lumber_registry
+            remove_method :inherited
+            alias_method :inherited, :inherited_without_lumber_registry
+          end
+        end
+
+      end
+    end
+
+    # Adds a inheritance handler to Object so we can add loggers for registered classes
+    def register_inheritance_handler
+      synchronize do
+
+        return if defined?(Object.inherited_with_lumber_registry)
+
+        Object.class_eval do
+
+          class << self
+
+            def inherited_with_lumber_registry(subclass)
+              inherited_without_lumber_registry(subclass)
+
+              # Add a logger to 'subclass' if it is directly in the registry
+              # No need to check full inheritance chain LoggerSupport handles it
+              # Also prevent rails from subsequently overriding our logger when rails
+              # is loaded after registering logger inheritance
+              if Lumber::InheritanceRegistry[subclass.name]
+                subclass.send(:include, Lumber::LoggerSupport)
+                subclass.send(:include, Lumber::PreventRailsOverride)
+              end
+            end
+
+            alias_method_chain :inherited, :lumber_registry
+
+          end
+
+        end
+
+      end
+    end
+
+  end
+
+end

data/lib/lumber/logger_support.rb

@@ -1,11 +1,35 @@
+require 'active_support/concern'
+require 'active_support/core_ext/module/delegation'
+
 module Lumber
 
   # Include this module to add a logger accessible from both class and instance methods.
-  # A logger heirarchy will be created if the class including this module is nested
+  # A logger hierarchy will be created if the class including this module is nested
   module LoggerSupport
+    extend ActiveSupport::Concern
+
+    included do
+
+      delegate :logger, :to => "self.class"
+
+    end
+
+    module ClassMethods
+
+
+      def logger
+        # This should probably be synchronized, but don't want to
+        # incur the performance hit on such a heavily used method.
+        # I think the worst case is that it'll just get assigned
+        # multiple times, but it'll get the same reference because
+        # Lumber.logger has a lock
+        @lumber_logger ||= Lumber.logger_for(self)
+      end
+
+      def logger=(logger)
+        @lumber_logger = logger
+      end
 
-    def self.included(receiver)
-      Lumber.setup_logger_hierarchy(receiver.name, "#{Lumber::BASE_LOGGER}::#{receiver.name}")
     end
 
   end

data/lib/lumber/lumber.rb

@@ -25,6 +25,9 @@ module Lumber
   # name of top level logger (can't be root as you can't have outputters on root)
   BASE_LOGGER= 'rails'
 
+  extend MonitorMixin
+  extend self
+
   # Initializes log4r system.  Needs to happen in
   # config/environment.rb before Rails::Initializer.run
   #
@@ -41,7 +44,7 @@ module Lumber
   # All config options get passed through to the log4r
   # configurator for use in defining outputters
   #
-  def self.init(opts = {})
+  def init(opts = {})
     opts[:root] ||= RAILS_ROOT.to_s if defined?(RAILS_ROOT)
     opts[:env] ||= RAILS_ENV if defined?(RAILS_ENV)
     opts[:config_file] ||= "#{opts[:root]}/config/log4r.yml"
@@ -63,11 +66,10 @@ module Lumber
     if defined?(RAILS_DEFAULT_LOGGER)
       Object.send(:remove_const, :RAILS_DEFAULT_LOGGER)
     end
-    Object.const_set('RAILS_DEFAULT_LOGGER', Log4r::Logger[BASE_LOGGER])
+    Object.const_set('RAILS_DEFAULT_LOGGER', find_or_create_logger(BASE_LOGGER))
+
+    Lumber::InheritanceRegistry.clear
 
-    self.registered_loggers.clear    
-    self.register_inheritance_handler()
-    
     if opts[:monitor_store]
       # Setting to Rails.cache handled by a post initialize_cache rails initializer
       # since Rails.cache is not available when lumber is initialized
@@ -76,12 +78,50 @@ module Lumber
     LevelUtil.start_monitor(opts[:monitor_interval]) if opts[:monitor_enabled]
   end
 
-  def self.find_or_create_logger(fullname)
-    Log4r::Logger[fullname] || Log4r::Logger.new(fullname)
+  def logger_name(clazz)
+    # Use the registered logger name if this class is in the registry
+    logger_name = Lumber::InheritanceRegistry[clazz.name]
+    if logger_name.nil?
+      # if not, find the first registered logger name in the superclass chain, if any
+      logger_name = Lumber::InheritanceRegistry.find_registered_logger(clazz.superclass)
+      if logger_name.nil?
+        # use name from clazz as we aren't inheriting
+        logger_name = "#{Lumber::BASE_LOGGER}#{Log4r::Log4rConfig::LoggerPathDelimiter}#{clazz.name}"
+      else
+        # base name on inherited logger and clazz since we are inheriting
+        # In log4r, a logger's parent is looked up from the name, and
+        # Lumber.find_or_create_logger ensures that loggers are created for
+        # all pieces of the name
+        logger_name = "#{logger_name}#{Log4r::Log4rConfig::LoggerPathDelimiter}#{clazz.name}"
+      end
+    end
+    logger_name
   end
-  
-  def self.registered_loggers
-    @registered_loggers ||= {}
+
+  def logger_for(clazz)
+    synchronize do
+      Lumber.find_or_create_logger(logger_name(clazz))
+    end
+  end
+
+  def find_or_create_logger(fullname)
+    synchronize do
+      logger = Log4r::Logger[fullname]
+      if logger.nil?
+        # build the loggers from the lhs up to ensure the name based logger inheritance gets applied
+        parts = fullname.split(Log4r::Log4rConfig::LoggerPathDelimiter)
+        aggregate_name = nil
+        parts.each do |part|
+          if aggregate_name.nil?
+            aggregate_name = part
+          else
+            aggregate_name = "#{aggregate_name}#{Log4r::Log4rConfig::LoggerPathDelimiter}#{part}"
+          end
+          logger = Log4r::Logger[aggregate_name] || Log4r::Logger.new(aggregate_name)
+        end
+      end
+      logger
+    end
   end
   
   # Makes :logger exist independently for subclasses and sets that logger
@@ -99,109 +139,24 @@ module Lumber
   # output will include "<class_name>" on every log from this class
   # so that you can tell where a log statement came from
   #
-  def self.setup_logger_hierarchy(class_name, class_logger_fullname)
-    Lumber.registered_loggers[class_name] = class_logger_fullname
+  def setup_logger_hierarchy(class_name, class_logger_fullname)
+    Lumber::InheritanceRegistry.register_inheritance_handler
+    Lumber::InheritanceRegistry[class_name] = class_logger_fullname
 
     begin
       clazz = class_name.constantize
-
-      # ActiveSupport 3.2 introduced class_attribute, which is supposed to be used instead of class_inheritable_accessor if available
-      [:class_attribute, :class_inheritable_accessor].each do |class_attribute_method|
-
-        if clazz.respond_to? class_attribute_method
-          clazz.class_eval do
-            send class_attribute_method, :logger
-            self.logger = Lumber.find_or_create_logger(class_logger_fullname)
-          end
-
-          break
-        end
-      end
-
+      clazz.send(:include, Lumber::LoggerSupport)
     rescue NameError
-      # The class hasn't been defined yet.  No problem, we've registered the logger for when the class is created.
+      # The class hasn't been defined yet.  No problem, we've registered
+      # the logger for when the class is created.
     end
   end
 
   # Helper to make it easier to log context through log4r.yml 
-  def self.format_mdc()
+  def format_mdc()
     ctx = Log4r::MDC.get_context.collect {|k, v| k.to_s + "=" + v.to_s }.join(" ")
     ctx.gsub!('%', '%%')
     return ctx
   end
-  
-  private
-
-  # Adds a inheritance handler to Object so we can know to add loggers
-  # for classes as they get defined.
-  def self.register_inheritance_handler()
-    return if defined?(Object.inherited_with_lumber_log4r)
-
-    Object.class_eval do
-
-      class << self
-
-        def inherited_with_lumber_log4r(subclass)
-          inherited_without_lumber_log4r(subclass)
-
-          # if the new class is in the list that were registered directly,
-          # then create their logger attribute directly, otherwise derive it
-          logger_name = Lumber.registered_loggers[subclass.name]
-          if logger_name
-            Lumber.add_lumber_logger(subclass, logger_name)
-          else
-            Lumber.derive_lumber_logger(subclass)
-          end
-        end
-
-        alias_method_chain :inherited, :lumber_log4r
-
-      end
-
-    end
-
-  end
-
-  def self.add_lumber_logger(clazz, logger_name)
-    clazz.class_eval do
-      # ActiveSupport 3.2 introduced class_attribute, which is supposed to be used instead of class_inheritable_accessor if available
-      if respond_to? :class_attribute
-        class_attribute :logger
-      else
-        class_inheritable_accessor :logger
-      end
-
-      self.logger = Lumber.find_or_create_logger(logger_name)
-
-      class << self
-
-        # Prevent rails from overwriting our logger
-        def cattr_accessor_with_lumber_log4r(*syms)
-          without_logger = syms.reject {|s| s == :logger}
-          cattr_accessor_without_lumber_log4r(*without_logger)
-        end
-        alias_method_chain :cattr_accessor, :lumber_log4r
-
-      end
-
-    end
-  end
 
-  def self.derive_lumber_logger(clazz)
-    # otherwise, walk up the classes hierarchy till you find a logger
-    # that was registered, and use that logger as the parent for the
-    # logger of the new class
-    parent = clazz.superclass
-    while ! parent.nil?
-      parent_logger_name = (parent.respond_to?(:logger) && parent.logger.respond_to?(:fullname)) ? parent.logger.fullname : ''
-      parent_is_registered = Lumber.registered_loggers.values.find {|v| parent_logger_name.index(v) == 0}
-      if parent_is_registered && parent.method_defined?(:logger=)
-        fullname = "#{parent_logger_name}::#{clazz.name.nil? ? 'anonymous' : clazz.name.split('::').last}"
-        clazz.logger = Lumber.find_or_create_logger(fullname)
-        break
-      end
-      parent = parent.superclass
-    end
-  end
-
-end
+end

data/lib/lumber/prevent_rails_override.rb

@@ -0,0 +1,25 @@
+require 'active_support/concern'
+
+module Lumber
+
+  # Include this module to add a logger accessible from both class and instance methods.
+  # A logger hierarchy will be created if the class including this module is nested
+  module PreventRailsOverride
+    extend ActiveSupport::Concern
+
+    included do
+
+      class << self
+        # Prevent rails from overwriting our logger
+        def cattr_accessor_with_lumber(*syms)
+          without_logger = syms.reject {|s| s == :logger}
+          cattr_accessor_without_lumber(*without_logger)
+        end
+        alias_method_chain :cattr_accessor, :lumber
+      end
+
+    end
+
+  end
+
+end

data/lib/lumber/railtie.rb

@@ -15,7 +15,7 @@ module Lumber
           Lumber.setup_logger_hierarchy("ActionController::Base", "rails::controllers")
           Lumber.setup_logger_hierarchy("ActionMailer::Base", "rails::mailers")      
         end
-        app.config.logger = Log4r::Logger[Lumber::BASE_LOGGER]
+        app.config.logger = Lumber.find_or_create_logger(Lumber::BASE_LOGGER)
         
         config_level = app.config.log_level
         if config_level.present?

data/lib/lumber/version.rb

@@ -1,3 +1,3 @@
 module Lumber
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end

data/spec/inheritance_registry_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Lumber::InheritanceRegistry do
+
+  before(:each) do
+    InheritanceRegistry.clear
+  end
+
+  it "allows registering a class" do
+    InheritanceRegistry['Foo'] = 'root::Foo'
+    InheritanceRegistry['Foo'].should == 'root::Foo'
+  end
+
+  it "allows clearing registry" do
+    InheritanceRegistry['Foo'] = 'root::Foo'
+    InheritanceRegistry['Foo'].should == 'root::Foo'
+    InheritanceRegistry.clear
+    InheritanceRegistry['Foo'].should be_nil
+  end
+
+  describe "#find_registered_logger" do
+
+    it "returns nil if clazz is nil" do
+      InheritanceRegistry.find_registered_logger(nil).should be_nil
+    end
+
+    it "returns the registered name if clazz is registered" do
+      class Foo; end
+      InheritanceRegistry['Foo'] = 'root::Foo'
+      InheritanceRegistry.find_registered_logger(Foo).should == "root::Foo"
+    end
+
+    it "returns the registered name if superclass is registered" do
+      class Foo; end
+      class Bar < Foo; end
+      InheritanceRegistry['Foo'] = 'root::Foo'
+      InheritanceRegistry.find_registered_logger(Bar).should == "root::Foo"
+    end
+
+    it "returns the registered name if superclass is registered" do
+      class Foo1; end
+      class Foo2 < Foo1; end
+      class Foo3 < Foo2; end
+      class Bar < Foo3; end
+      InheritanceRegistry['Foo1'] = 'root::Foo1'
+      InheritanceRegistry.find_registered_logger(Bar).should == "root::Foo1"
+    end
+
+    it "doesn't use classes past first registered superclass" do
+      class Foo1; end
+      class Foo2 < Foo1; end
+      class Foo3 < Foo2; end
+      class Bar < Foo3; end
+      InheritanceRegistry['Foo1'] = 'root::Foo1'
+      InheritanceRegistry['Foo2'] = 'root::Foo2'
+      InheritanceRegistry.find_registered_logger(Bar).should == "root::Foo2"
+    end
+
+  end
+
+  describe "#remove_inheritance_handler" do
+
+    it "should remove the handler" do
+      defined?(Object.inherited_with_lumber_registry).should be_false
+      InheritanceRegistry.register_inheritance_handler
+      defined?(Object.inherited_with_lumber_registry).should be_true
+      InheritanceRegistry.remove_inheritance_handler
+      defined?(Object.inherited_with_lumber_registry).should be_false
+    end
+
+  end
+
+  describe "#register_inheritance_handler" do
+
+    before(:each) do
+      InheritanceRegistry.remove_inheritance_handler
+    end
+
+    it "adds an inheritance handler" do
+      defined?(Object.inherited_with_lumber_registry).should be_false
+      InheritanceRegistry.register_inheritance_handler
+      defined?(Object.inherited_with_lumber_registry).should be_true
+    end
+
+    it "doesn't add an inheritance handler multiple times" do
+      Object.singleton_class.should_receive(:alias_method_chain).once.and_call_original
+      defined?(Object.inherited_with_lumber_registry).should be_false
+      InheritanceRegistry.register_inheritance_handler
+      defined?(Object.inherited_with_lumber_registry).should be_true
+      InheritanceRegistry.register_inheritance_handler
+      defined?(Object.inherited_with_lumber_registry).should be_true
+    end
+
+    it "doesn't change classes that aren't registered" do
+      InheritanceRegistry.register_inheritance_handler
+      class Foo; end
+      Foo.ancestors.should_not include(Lumber::LoggerSupport)
+      Foo.ancestors.should_not include(Lumber::PreventRailsOverride)
+    end
+
+    it "adds logger support for classes that are registered" do
+      InheritanceRegistry.register_inheritance_handler
+      InheritanceRegistry["Foo"] = "root::Foo"
+      class Foo; end
+      Foo.ancestors.should include(Lumber::LoggerSupport)
+      Foo.ancestors.should include(Lumber::PreventRailsOverride)
+    end
+
+  end
+
+end

data/spec/level_util_spec.rb

@@ -7,7 +7,7 @@ describe Lumber::LevelUtil do
     root = "#{File.dirname(__FILE__)}/.."
     Lumber.init(:root => root,
                 :env => 'test',
-                :config_file => "#{root}/generators/lumber/templates/log4r.yml",
+                :config_file => "#{root}/lib/generators/lumber/templates/log4r.yml",
                 :log_file => "/tmp/lumber-test.log")
 
     @name = "foo_#{Time.now.to_f}"

data/spec/logger_support_spec.rb

@@ -6,34 +6,36 @@ describe Lumber::LoggerSupport do
     root = "#{File.dirname(__FILE__)}/.."
     Lumber.init(:root => root,
                 :env => 'test',
-                :config_file => "#{root}/generators/lumber/templates/log4r.yml",
+                :config_file => "#{root}/lib/generators/lumber/templates/log4r.yml",
                 :log_file => "/tmp/lumber-test.log")
   end
 
-  after(:each) do
-    self.class.constants.grep(/^Foo/).each do |c|
-      self.send(:remove_const, c)
-    end
+  it "should memoize logger" do
+    class Foo; include Lumber::LoggerSupport; end
+    Lumber.should_receive(:logger_for).once.and_call_original
+
+    Foo.logger.fullname.should == "rails::Foo"
+    Foo.logger.fullname.should == "rails::Foo"
   end
 
-  it "should create logger for chain" do
+  it "makes a logger available for subclasses" do
     class Foo; include Lumber::LoggerSupport; end
     class Bar < Foo; end;
-    Foo.logger.should == Log4r::Logger["rails::Foo"]
-    Bar.logger.should == Log4r::Logger["rails::Foo::Bar"]
-    Bar.logger.parent.should == Log4r::Logger["rails::Foo"]
+    Foo.logger.fullname.should == "rails::Foo"
+    Bar.logger.fullname.should == "rails::Bar"
+    Bar.logger.parent.fullname.should == "rails"
   end
 
   it "should have a logger instance accessible from an instance method" do
     class Foo; include Lumber::LoggerSupport; def member_method; logger.debug('hi'); end; end
-    logger = Log4r::Logger["rails::Foo"]
+    logger = Lumber.find_or_create_logger("rails::Foo")
     logger.should_receive(:debug).with('hi')
     Foo.new.member_method
   end
 
   it "should have a logger instance accessible from a class method " do
     class Foo; include Lumber::LoggerSupport; def self.class_method; logger.debug('hi'); end; end
-    logger = Log4r::Logger["rails::Foo"]
+    logger = Lumber.find_or_create_logger("rails::Foo")
     logger.should_receive(:debug).with('hi')
     Foo.class_method
   end
@@ -52,7 +54,7 @@ describe Lumber::LoggerSupport do
     
     cfg = Log4r::YamlConfigurator
     cfg.load_yaml_string(yml)
-    logger = Log4r::Logger['rails::Foo']
+    logger = Lumber.find_or_create_logger("rails::Foo")
     sio = StringIO.new 
     logger.outputters = [Log4r::IOOutputter.new("sbout", sio)]
     class Foo; include Lumber::LoggerSupport; end

data/spec/lumber_spec.rb

@@ -1,157 +1,194 @@
 require 'spec_helper'
 require 'delegate'
 
-def new_class(class_name, super_class=nil, super_module=nil)
-  s = "class #{class_name}"
-  s << " < #{super_class}" if super_class
-  s << "; end"
-
-  s = "module #{super_module}; #{s}; end" if super_module
-
-  eval s
-end
-  
 describe Lumber do
 
   before(:each) do
     root = "#{File.dirname(__FILE__)}/.."
     Lumber.init(:root => root,
                 :env => 'test',
-                :config_file => "#{root}/generators/lumber/templates/log4r.yml",
+                :config_file => "#{root}/lib/generators/lumber/templates/log4r.yml",
                 :log_file => "/tmp/lumber-test.log")
   end
 
-  after(:each) do
-    Object.constants.grep(/^Foo/).each do |c|
-      Object.send(:remove_const, c)
+  describe "#logger_name" do
+
+    it "generates a name for a simple class" do
+      new_class('Foo')
+      Lumber.logger_name(Foo).should == "rails::Foo"
     end
-  end
 
-  def assert_valid_logger(class_name, logger_name)
-    clazz = eval class_name
-    clazz.should_not be_nil
-    clazz.respond_to?(:logger).should be_true
-    lgr = clazz.logger
-    lgr.should be_an_instance_of(Log4r::Logger)
-    lgr.fullname.should == logger_name
-  end
+    it "generates a name for a registered class" do
+      Lumber.setup_logger_hierarchy("Foo", "root::foo")
+      new_class('Foo')
+      Lumber.logger_name(Foo).should == "root::foo"
+    end
 
-  it "should not do anything if no loggers registered" do
-    defined?(Object.inherited_with_lumber_log4r).should be_true
-    defined?(Object.logger).should be_false
-  end
+    it "generates a name for a subclass" do
+      Lumber.setup_logger_hierarchy("Foo", "root::foo")
+      new_class('Foo')
+      new_class('Bar', 'Foo')
+      Lumber.logger_name(Bar).should == "root::foo::Bar"
+    end
 
-  it "should allow registering logger for a class before the class is defined" do
-    defined?(Foo1).should be_false
-    Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
-    new_class('Foo1')
-    assert_valid_logger('Foo1', "root::foo1")
-  end
+    it "generates a name for a deep subclass" do
+      Lumber.setup_logger_hierarchy("Foo", "root::foo")
+      new_class('Foo')
+      new_class('Foo1', 'Foo')
+      new_class('Bar', 'Foo1')
+      Lumber.logger_name(Bar).should == "root::foo::Bar"
+    end
 
-  it "should not register new logger for subclasses of classes that delegate logger" do
-    defined?(Foo1).should be_false # ActionController::Base
-    defined?(Foo2).should be_false # ActionView::Base
-    defined?(Foo3).should be_false # Subclass of ActionView::Base
-    Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
-    eval "class ::Foo1; end"
-    eval "class ::Foo2; delegate :logger, :to => Foo1; end"
-    eval "class ::Foo3 < Foo2; end"
-    assert_valid_logger('Foo1', "root::foo1")
-    Foo2.new.logger.should == Foo1.logger
-    Foo3.new.logger.should == Foo1.logger
   end
 
-  it "should no logger when parent is via delegate class" do
-    defined?(Foo1).should be_false
-    defined?(Foo2).should be_false
-    defined?(Foo3).should be_false
-    Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
-    eval "class ::Foo1; end"
-    eval "class ::Foo2 < DelegateClass(Foo1); end"
-    eval "class ::Foo3 < Foo2; end"
-    assert_valid_logger('Foo1', "root::foo1")
-    defined?(Foo3.logger).should be_false
-  end
+  describe "#logger_for" do
+
+     it "gets the logger" do
+       new_class('Foo')
+       Lumber.logger_for(Foo).fullname.should == "rails::Foo"
+     end
 
-  it "should allow registering independent loggers for classes in a hierarchy" do
-    defined?(Foo1).should be_false
-    defined?(Foo2).should be_false
-    Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
-    Lumber.setup_logger_hierarchy("Foo2", "root::foo2")
-    new_class('Foo1')
-    new_class('Foo2', 'Foo1')
-    assert_valid_logger('Foo1', "root::foo1")
-    assert_valid_logger('Foo2', "root::foo2")
   end
 
-  it "should prevent cattr_accessor for a class registered before the class is defined" do
-    defined?(Foo1).should be_false
-    Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
-    new_class('Foo1')
-    Foo1.class_eval do
-      cattr_accessor :logger, :foo
+  describe "#find_or_create_logger" do
+
+    it "creates loggers for each segment" do
+      Log4r::Logger['foo1'].should be_nil
+      Log4r::Logger['foo1::foo2'].should be_nil
+      Log4r::Logger['foo1::foo2::foo3'].should be_nil
+      Log4r::Logger['foo1::foo2::foo3::bar'].should be_nil
+
+      Lumber.find_or_create_logger("foo1::foo2::foo3::bar")
+
+      Log4r::Logger['foo1'].should_not be_nil
+      Log4r::Logger['foo1'].parent.should == Log4r::Logger['root']
+      Log4r::Logger['foo1::foo2'].should_not be_nil
+      Log4r::Logger['foo1::foo2'].parent.should == Log4r::Logger['foo1']
+      Log4r::Logger['foo1::foo2::foo3'].should_not be_nil
+      Log4r::Logger['foo1::foo2::foo3'].parent.should == Log4r::Logger['foo1::foo2']
+      Log4r::Logger['foo1::foo2::foo3::bar'].should_not be_nil
+      Log4r::Logger['foo1::foo2::foo3::bar'].parent.should == Log4r::Logger['foo1::foo2::foo3']
+    end
+
+    it "only creates loggers once" do
+      Log4r::Logger.should_receive(:new).twice.and_call_original
+      Lumber.find_or_create_logger("bar1::bar2")
+      Lumber.find_or_create_logger("bar1::bar2")
     end
-    defined?(Foo1.foo).should be_true
-    assert_valid_logger('Foo1', "root::foo1")
-  end
 
-  it "should allow registering logger for a nested class before the class is defined" do
-    defined?(Bar1::Foo1).should be_false
-    Lumber.setup_logger_hierarchy("Bar1::Foo1", "root::foo1")
-    new_class('Foo1', nil, 'Bar1')
-    assert_valid_logger('Bar1::Foo1', "root::foo1")
   end
 
-  it "should allow registering logger for a class after the class is defined" do
-    defined?(Foo1).should be_false
-    new_class('Foo1')
-    defined?(Foo1).should be_true
+  describe "#setup_logger_hierarchy" do
 
-    Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
-    assert_valid_logger('Foo1', "root::Foo1")
-  end
+    it "should allow registering logger for a class before the class is defined" do
+      defined?(Foo1).should be_false
+      Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
+      new_class('Foo1')
+      assert_valid_logger('Foo1', "root::foo1")
+    end
 
-  it "should register loggers for subclasses of registered classes" do
-    defined?(Foo1).should be_false
-    defined?(Foo2).should be_false
-    defined?(Foo3).should be_false
-    Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
-    new_class('Foo1')
-    new_class('Foo2', 'Foo1')
-    new_class('Foo3')
-    assert_valid_logger('Foo1', "root::Foo1")
-    assert_valid_logger('Foo2', "root::Foo1::Foo2")
-    defined?(Foo3.logger).should be_false
-  end
+    it "should not register new logger for subclasses of classes that delegate logger" do
+      defined?(Foo1).should be_false # ActionController::Base
+      defined?(Foo2).should be_false # ActionView::Base
+      defined?(Foo3).should be_false # Subclass of ActionView::Base
+      Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
+      eval "class ::Foo1; end"
+      eval "class ::Foo2; delegate :logger, :to => Foo1; end"
+      eval "class ::Foo3 < Foo2; end"
+      assert_valid_logger('Foo1', "root::foo1")
+      Foo2.new.logger.should == Foo1.logger
+      Foo3.new.logger.should == Foo1.logger
+    end
 
-  it "should register loggers for sub-subclasses of registered classes" do
-    defined?(Foo1).should be_false
-    defined?(Foo2).should be_false
-    defined?(Foo3).should be_false
-    Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
-    new_class('Foo1')
-    new_class('Foo2', 'Foo1')
-    new_class('Foo3', 'Foo2')
-    assert_valid_logger('Foo1', "root::Foo1")
-    assert_valid_logger('Foo2', "root::Foo1::Foo2")
-    assert_valid_logger('Foo3', "root::Foo1::Foo2::Foo3")
-  end
+    it "should no logger when parent is via delegate class" do
+      defined?(Foo1).should be_false
+      defined?(Foo2).should be_false
+      defined?(Foo3).should be_false
+      Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
+      eval "class ::Foo1; end"
+      eval "class ::Foo2 < DelegateClass(Foo1); end"
+      eval "class ::Foo3 < Foo2; end"
+      assert_valid_logger('Foo1', "root::foo1")
+      defined?(Foo3.logger).should be_false
+    end
+
+    it "should allow registering independent loggers for classes in a hierarchy" do
+      defined?(Foo1).should be_false
+      defined?(Foo2).should be_false
+      Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
+      Lumber.setup_logger_hierarchy("Foo2", "root::foo2")
+      new_class('Foo1')
+      new_class('Foo2', 'Foo1')
+      assert_valid_logger('Foo1', "root::foo1")
+      assert_valid_logger('Foo2', "root::foo2")
+    end
+
+    it "should prevent cattr_accessor for a class registered before the class is defined" do
+      defined?(Foo1).should be_false
+      Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
+      new_class('Foo1')
+      Foo1.class_eval do
+        cattr_accessor :logger, :foo
+      end
+      defined?(Foo1.foo).should be_true
+      assert_valid_logger('Foo1', "root::foo1")
+    end
+
+    it "should allow registering logger for a nested class before the class is defined" do
+      defined?(Bar1::Foo1).should be_false
+      Lumber.setup_logger_hierarchy("Bar1::Foo1", "root::foo1")
+      new_class('Foo1', nil, 'Bar1')
+      assert_valid_logger('Bar1::Foo1', "root::foo1")
+    end
+
+    it "should allow registering logger for a class after the class is defined" do
+      defined?(Foo1).should be_false
+      new_class('Foo1')
+      defined?(Foo1).should be_true
+
+      Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
+      assert_valid_logger('Foo1', "root::Foo1")
+    end
+
+    it "should register loggers for subclasses of registered classes" do
+      defined?(Foo1).should be_false
+      defined?(Foo2).should be_false
+      defined?(Foo3).should be_false
+      Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
+      new_class('Foo1')
+      new_class('Foo2', 'Foo1')
+      new_class('Foo3')
+      assert_valid_logger('Foo1', "root::Foo1")
+      assert_valid_logger('Foo2', "root::Foo1::Foo2")
+      defined?(Foo3.logger).should be_false
+    end
+
+    it "should register loggers for sub-subclasses of registered classes" do
+      defined?(Foo1).should be_false
+      defined?(Foo2).should be_false
+      defined?(Foo3).should be_false
+      Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
+      new_class('Foo1')
+      new_class('Foo2', 'Foo1')
+      new_class('Foo3', 'Foo2')
+      assert_valid_logger('Foo1', "root::Foo1")
+      assert_valid_logger('Foo2', "root::Foo1::Foo2")
+      assert_valid_logger('Foo3', "root::Foo1::Foo3")
+    end
+
+    it "should register loggers for sub-subclasses of registered classes even when middle class not a logger" do
+      defined?(Foo1).should be_false
+      defined?(Foo2).should be_false
+      defined?(Foo3).should be_false
+      new_class('Foo1')
+      new_class('Foo2', 'Foo1')
+      Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
+      new_class('Foo3', 'Foo2')
+      assert_valid_logger('Foo1', "root::Foo1")
+      assert_valid_logger('Foo3', "root::Foo1::Foo3")
+      assert_valid_logger('Foo2', "root::Foo1::Foo2")
+    end
 
-  it "should register loggers for sub-subclasses of registered classes even when middle class not a logger" do
-    defined?(Foo1).should be_false
-    defined?(Foo2).should be_false
-    defined?(Foo3).should be_false
-    new_class('Foo1')
-    new_class('Foo2', 'Foo1')
-    Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
-    new_class('Foo3', 'Foo2')
-    assert_valid_logger('Foo1', "root::Foo1")
-    # this will behave differently depending on the version of ActiveSupport being used. on ActiveSupport >= 3.2, we use class_attribute to define
-    # the logger method, which will cause subclasses to fall back to the parent class's logger if one isn't defined (Foo2.logger == Foo1.logger)
-    # if on ActiveSupport < 3.2, we use class_inheritable_accessor, which will leave the logger undefined in the subclass unless LoggerSupport
-    # is explicitly included
-    ((!defined?(Foo2.logger) || Foo2.logger.nil?) || (Foo2.logger == Foo1.logger)).should be_true
-    assert_valid_logger('Foo3', "root::Foo1::Foo3")
   end
 
   context "formatted MDC context" do

data/spec/prevent_rails_override_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Lumber::PreventRailsOverride do
+
+  it "should prevent cattr_accessor for :logger" do
+    new_class('Foo1')
+    Foo1.send(:include, Lumber::PreventRailsOverride)
+    Foo1.class_eval do
+      cattr_accessor :logger
+    end
+    defined?(Foo1.logger).should be_false
+  end
+
+  it "should allow cattr_accessor for attrs other than :logger" do
+    new_class('Foo1')
+    Foo1.send(:include, Lumber::PreventRailsOverride)
+    Foo1.class_eval do
+      cattr_accessor :foo
+    end
+    defined?(Foo1.foo).should be_true
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 ENV['RACK_ENV'] = 'test'
 
-if ENV['CI']
+# coveralls+rspec+java causes exit code of 1 even when specs pass
+if ENV['CI'] && RUBY_ENGINE != 'jruby'
   require 'coveralls'
   Coveralls.wear!
 end
@@ -24,3 +25,30 @@ include Lumber
 require 'capybara/rspec'
 require 'capybara/poltergeist'
 Capybara.javascript_driver = :poltergeist
+
+def new_class(class_name, super_class=nil, super_module=nil)
+  s = "class #{class_name}"
+  s << " < #{super_class}" if super_class
+  s << "; end"
+
+  s = "module #{super_module}; #{s}; end" if super_module
+
+  eval s
+end
+
+def assert_valid_logger(class_name, logger_name)
+  clazz = eval class_name
+  clazz.should_not be_nil
+  clazz.respond_to?(:logger).should be_true
+  lgr = clazz.logger
+  lgr.should be_an_instance_of(Log4r::Logger)
+  lgr.fullname.should == logger_name
+end
+
+RSpec.configure do |config|
+  config.before(:each) do
+    Object.constants.grep(/^(Foo|Bar)/).each do |c|
+      Object.send(:remove_const, c)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lumber
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Matt Conway
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-11 00:00:00.000000000 Z
+date: 2013-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: log4r
@@ -171,15 +171,16 @@ files:
 - README.md
 - Rakefile
 - TODO
-- generators/lumber/USAGE
-- generators/lumber/lumber_generator.rb
-- generators/lumber/templates/log4r.yml
+- lib/generators/lumber/lumber_generator.rb
+- lib/generators/lumber/templates/log4r.yml
 - lib/lumber.rb
+- lib/lumber/inheritance_registry.rb
 - lib/lumber/json_formatter.rb
 - lib/lumber/level_util.rb
 - lib/lumber/log4r.rb
 - lib/lumber/logger_support.rb
 - lib/lumber/lumber.rb
+- lib/lumber/prevent_rails_override.rb
 - lib/lumber/railtie.rb
 - lib/lumber/server.rb
 - lib/lumber/server/public/lib/bootstrap/css/bootstrap-responsive.css
@@ -196,10 +197,12 @@ files:
 - lib/lumber/server/views/levels.erb
 - lib/lumber/version.rb
 - lumber.gemspec
+- spec/inheritance_registry_spec.rb
 - spec/json_formatter_spec.rb
 - spec/level_util_spec.rb
 - spec/logger_support_spec.rb
 - spec/lumber_spec.rb
+- spec/prevent_rails_override_spec.rb
 - spec/server_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -228,10 +231,12 @@ signing_key:
 specification_version: 4
 summary: Lumber integrates the log4r logging system within your application.
 test_files:
+- spec/inheritance_registry_spec.rb
 - spec/json_formatter_spec.rb
 - spec/level_util_spec.rb
 - spec/logger_support_spec.rb
 - spec/lumber_spec.rb
+- spec/prevent_rails_override_spec.rb
 - spec/server_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb

data/generators/lumber/USAGE

@@ -1,5 +0,0 @@
-Description:
-    Prepares the rails application for using log4 by installing sample configuration
-
-Examples:
-    ./script/generate lumber

data/generators/lumber/lumber_generator.rb

@@ -1,19 +0,0 @@
-require 'fileutils'
-require 'find'
-
-class LumberGenerator < Rails::Generator::Base
-
-  def manifest
-    record do |m|
-      m.file('log4r.yml', 'config/log4r.yml')
-    end
-  end
-
-  protected
-
-  def banner
-    usage = "Usage: #{$0} lumber\n"
-    usage << "    Install configuration files for lumber\n"
-    return usage
-  end
-end