catamaran 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5e6d25e6550c1bcba63f44167d3e53de5950a528
-  data.tar.gz: 76e8decccaa647af4a1ebf5622ecf0594d0b5a49
+  metadata.gz: 0e807d462b178ce06016ad76babba6ba142928f9
+  data.tar.gz: 240ed2615b1b49361f3c49ba5be63bf2a5edafa8
 SHA512:
-  metadata.gz: cf04c77d2d57455b5899a232dc364e939da2280301e02891096ec19c5ca254702269e3d80b6c2530ba515c7f423eaa1f4d3f7386b4f2cf796ed07336b7840cec
-  data.tar.gz: d36ab4e2705db71915e064ca6986bc09d3292f929ad557438c28f176513f5469485344fcf28bf4ffeb709dcc41b819166b5ef1bde3551ac38b3a3578205fe8da
+  metadata.gz: 1214f644cbecf098a31703930f6dfe4aed9715faa88ffa7acfcc8dbc8759e69f14104ff6ce72baa8317f35376ae71a7dd41bce1aad194c53b130c4c76f2132eb
+  data.tar.gz: 784259e5224043161d3b23bea3088e4f8328cd23b36feeabdebaf3f5edbde2b28d41588577aff6d41864f4935aaed8eeb24eeee225856dda61312842a988586d

data/README.md

@@ -6,7 +6,7 @@ Logging is a powerful and often undervalued tool in software development.  When
 Gemfile
 -------
 
-    gem 'catamaran', '~> 0.6.0'
+    gem 'catamaran', '~> 0.7.0'
 
 Rails-related setup:
 
@@ -64,14 +64,15 @@ Other Ruby Examples
 -------------------
     require 'catamaran'
 
-    Catamaran::LogLevel.default_log_level = Catamaran::LogLevel::TRACE 
+    Catamaran.logger.log_level = Catamaran::LogLevel::INFO 
+    Catamaran.logger.backtrace_log_level = Catamaran::LogLevel::ERROR 
     Catamaran::Manager.formatter_class = Catamaran::Formatter::NoCallerFormatter
 
     class SecondRubyDemo
       LOGGER = Catamaran.logger( { :class => name(), :file => __FILE__ } )
 
       def run
-        LOGGER.trace( "Sample TRACE statement", { :line => __LINE__, :method => 'run'} ) if LOGGER.trace?
+        LOGGER.info( "Sample INFO statement", { :line => __LINE__, :method => 'run'} ) if LOGGER.info?
       end
     end 
 
@@ -79,8 +80,9 @@ Other Ruby Examples
       LOGGER = Catamaran.logger( "com.mycompany.ThirdRubyDemo", { :class => name(), :file => __FILE__ } )
 
       def run
-        LOGGER.debug( "Sample DEBUG statement", { :line => __LINE__, :method => 'run' } ) if LOGGER.debug?
-        LOGGER.debug( "Sample DEBUG statement with backtrace option", { :line => __LINE__, :method => 'run', :backtrace => true } ) if LOGGER.debug?
+        LOGGER.warn( "Sample WARN statement", { :line => __LINE__, :method => 'run' } ) if LOGGER.warn?
+        LOGGER.warn( "Sample WARN statement with backtrace option", { :line => __LINE__, :method => 'run', :backtrace => true } ) if LOGGER.warn?
+        LOGGER.error( "Sample ERROR statement with backtrace option", { :line => __LINE__, :method => 'run', :backtrace => true } ) if LOGGER.error?        
       end
     end   
 
@@ -89,11 +91,13 @@ Other Ruby Examples
 
 And the output
 
-     TRACE pid-4714 [2013-12-26 15:33:05:311]                                                 - Sample TRACE statement (catamaran_ruby_demos.rb:11:in `SecondRubyDemo.run')
-     DEBUG pid-4714 [2013-12-26 15:33:05:311]                     com.mycompany.ThirdRubyDemo - Sample DEBUG statement (catamaran_ruby_demos.rb:19:in `ThirdRubyDemo.run')
-     DEBUG pid-4714 [2013-12-26 15:33:05:311]                     com.mycompany.ThirdRubyDemo - Sample DEBUG statement with backtrace option (catamaran_ruby_demos.rb:20:in `ThirdRubyDemo.run') from:
-    catamaran_ruby_demos.rb:20:in `run'
-    catamaran_ruby_demos.rb:25:in `<main>'
+      INFO pid-5973 [2013-12-27 17:18:09:115]                                                 - Sample INFO statement (catamaran_ruby_demos.rb:12:in `SecondRubyDemo.run')
+      WARN pid-5973 [2013-12-27 17:18:09:115]                     com.mycompany.ThirdRubyDemo - Sample WARN statement (catamaran_ruby_demos.rb:20:in `ThirdRubyDemo.run')
+      WARN pid-5973 [2013-12-27 17:18:09:115]                     com.mycompany.ThirdRubyDemo - Sample WARN statement with backtrace option (catamaran_ruby_demos.rb:21:in `ThirdRubyDemo.run')
+     ERROR pid-5973 [2013-12-27 17:18:09:115]                     com.mycompany.ThirdRubyDemo - Sample ERROR statement with backtrace option (catamaran_ruby_demos.rb:22:in `ThirdRubyDemo.run') from:
+    catamaran_ruby_demos.rb:22:in `run'
+    catamaran_ruby_demos.rb:27:in `<main>'
+
 
 
 
@@ -108,7 +112,9 @@ I'm looking for a logging utility that:
 * supports the TRACE log level (or other log level less critical than DEBUG). 
 * is capable of capturing logs at different log level thresholds from different parts of the app simultaneously
 * readily works with Rails
-
+* http://stackoverflow.com/questions/462651/rails-logger-format-string-configuration
+* http://stackoverflow.com/questions/3654827/logging-in-rails-app
+* http://stackoverflow.com/questions/11991967/rails-log-too-verbose
 
 Performance Considerations
 --------------------------
@@ -185,7 +191,6 @@ ex:
     require 'catamaran'
     require 'benchmark'
 
-    Catamaran::LogLevel.default_log_level = Catamaran::LogLevel::INFO 
     Catamaran::Manager.stderr = false
 
     class CatamaranPerformanceTest
@@ -239,8 +244,9 @@ Ideas around what's next
 * Consider capturing log messages beyond stderr, stdout, and local files
 * Ongoing performance considerations
 * Something like `filter_parameter_logging`
-* Optional backtrace support for certain logs
 * Color support
+* Log rotation
+* Heroku support
 
 
 

data/lib/catamaran/formatter/base_formatter.rb

@@ -19,7 +19,7 @@ module Catamaran
 
       def self.construct_backtrace_info( opts )
         if opts && opts[:backtrace] == true
-          msg = " from:\n#{caller(4).take(10).join("\n")}"
+          msg = " from:\n#{caller(5).take(10).join("\n")}"
         else
           msg = ''
         end

data/lib/catamaran/log_level.rb

@@ -7,10 +7,6 @@ module Catamaran
     IO_LESS_CRITICAL_THAN_DEBUG = 2080
     IO_LESS_CRITICAL_THAN_INFO = 3080
 
-    BACKTRACE_LESS_CRITICAL_THAN_TRACE = 1070
-    BACKTRACE_LESS_CRITICAL_THAN_DEBUG = 2070
-    BACKTRACE_LESS_CRITICAL_THAN_INFO = 3070
-
     ALL = 100
 
     TRACE = 2000 
@@ -22,18 +18,10 @@ module Catamaran
     FATAL = 8000
 
     IO = IO_LESS_CRITICAL_THAN_INFO
-    BACKTRACE = BACKTRACE_LESS_CRITICAL_THAN_INFO
-
-
 
     def self.reset
-      @@default_log_level = INFO
-
       self.send( :remove_const, 'IO' ) if self.const_defined?( 'IO' )
-      self.const_set( 'IO', IO_LESS_CRITICAL_THAN_INFO )      
-
-      self.send( :remove_const, 'BACKTRACE' ) if self.const_defined?( 'BACKTRACE' )
-      self.const_set( 'BACKTRACE', BACKTRACE_LESS_CRITICAL_THAN_INFO )       
+      self.const_set( 'IO', IO_LESS_CRITICAL_THAN_INFO )            
     end
 
     self.reset()
@@ -62,16 +50,7 @@ module Catamaran
       end
 
       retval
-    end
-
-    def self.default_log_level
-      @@default_log_level
-    end    
-
-    def self.default_log_level=( value )
-      Catamaran.debugging( "Catamaran::LogLevel#default_log_level=() - Switching the default log level to #{value}" ) if Catamaran.debugging?            
-      @@default_log_level = value
-    end
+    end   
 
     def self.log_level_io=( value )
       self.send( :remove_const, 'IO' ) if self.const_defined?( 'IO' )
@@ -80,15 +59,6 @@ module Catamaran
 
     def self.log_level_io
       IO
-    end 
-
-    def self.log_level_backtrace=( value )
-      self.send( :remove_const, 'BACKTRACE' ) if self.const_defined?( 'BACKTRACE' )
-      self.const_set( 'BACKTRACE', value ) 
-    end
-
-    def self.log_level_backtrace
-      BACKTRACE
     end        
   end
 end

data/lib/catamaran/logger.rb

@@ -15,7 +15,7 @@ module Catamaran
         retval = @log_level
       elsif self.parent.nil?
         # No parent means this logger(self) is the root logger.  So use the default log level
-        retval = Catamaran::LogLevel.default_log_level()
+        retval = Catamaran::LogLevel::INFO
       else
         recursive = opts[:recursive]
         if recursive == true 
@@ -51,6 +51,87 @@ module Catamaran
       @log_level = value
       remove_instance_variable( :@memoized_log_level ) if instance_variable_defined?( :@memoized_log_level )      
     end
+
+
+
+
+
+
+
+
+
+
+
+
+    def backtrace_log_level( opts = {} )
+      if instance_variable_defined?( :@backtrace_log_level ) && @backtrace_log_level
+        retval = @backtrace_log_level
+      elsif self.parent.nil?
+        # No parent means this logger(self) is the root logger.  So use the default log level
+        retval = Catamaran::LogLevel::WARN
+      else
+        recursive = opts[:recursive]
+        if recursive == true 
+
+          # Remember the log level we found so we don't have to recursively look for it ever time
+          if !instance_variable_defined?( :@memoized_backtrace_log_level ) || @memoized_backtrace_log_level.nil?
+            @memoized_backtrace_log_level = parent.backtrace_log_level( opts ) if parent
+          end
+
+          retval = @memoized_backtrace_log_level
+        else
+          Catamaran.debugging( "Catamaran::Logger#backtrace_log_level() - non-recrusive request for log level.  And log level is nil.  This shouldn't happen too often." ) if Catamaran.debugging?        
+          retval = nil
+        end
+      end
+
+      # Implicit return
+      retval
+    end
+
+    ## 
+    # We usually want a logger to have a level.   The smart_backtrace_log_level() reader determines a log level even if one isn't
+    # explicitly set on this logger instance by making use of recursion up to the root logger if needed
+
+    def smart_backtrace_log_level
+      self.backtrace_log_level( { :recursive => true } )
+    end
+
+    ##
+    # Setter used to explicitly set the log level for this logger
+
+    def backtrace_log_level=( value )
+      @backtrace_log_level = value
+      remove_instance_variable( :@memoized_backtrace_log_level ) if instance_variable_defined?( :@memoized_backtrace_log_level )      
+    end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
     ##
     # Is trace-level logging currently enabled?
@@ -65,7 +146,7 @@ module Catamaran
 
     def trace( msg, opts = nil )
       if trace?
-        _log( LogLevel::TRACE, msg, opts )
+        log( LogLevel::TRACE, msg, opts )
       end
     end
 
@@ -82,7 +163,7 @@ module Catamaran
 
     def debug( msg, opts = nil )
       if debug?
-        _log( LogLevel::DEBUG, msg, opts )
+        log( LogLevel::DEBUG, msg, opts )
       end
     end
 
@@ -100,7 +181,7 @@ module Catamaran
 
     def io( msg, opts = nil )
       if io?
-        _log( LogLevel::IO, msg, opts )
+        log( LogLevel::IO, msg, opts )
       end
     end
 
@@ -117,7 +198,7 @@ module Catamaran
 
     def info( msg, opts = nil )
       if info?
-        _log( LogLevel::INFO, msg, opts )
+        log( LogLevel::INFO, msg, opts )
       end
     end 
 
@@ -134,7 +215,7 @@ module Catamaran
 
     def warn( msg, opts = nil )
       if warn?
-        _log( LogLevel::WARN, msg, opts )
+        log( LogLevel::WARN, msg, opts )
       end
     end     
 
@@ -151,7 +232,7 @@ module Catamaran
 
     def error( msg, opts = nil )
       if error?
-        _log( LogLevel::ERROR, msg, opts )
+        log( LogLevel::ERROR, msg, opts )
       end
     end 
 
@@ -168,7 +249,7 @@ module Catamaran
 
     def severe( msg, opts = nil )
       if severe?
-        _log( LogLevel::SEVERE, msg, opts )
+        log( LogLevel::SEVERE, msg, opts )
       end
     end   
 
@@ -185,20 +266,12 @@ module Catamaran
 
     # def fatal( msg, opts = nil )
     #   if fatal?
-    #     _log( LogLevel::FATAL, msg, opts )
+    #     log( LogLevel::FATAL, msg, opts )
     #   end
     # end            
 
-    ##
-    # Is backtrace-level logging currently enabled? (Special case)
 
-    def backtrace?
-      if self.smart_log_level() <= LogLevel::BACKTRACE
-        true
-      else
-        false
-      end
-    end
+
 
     ##
     # Usually get_logger is a reference to self, unless a path has been specified as a parameter
@@ -315,7 +388,8 @@ module Catamaran
 
     def reset( opts = {} )
       remove_instance_variable(:@memoized_log_level) if instance_variable_defined?( :@memoized_log_level )      
-      remove_instance_variable(:@log_level) if instance_variable_defined?( :@log_level )      
+      remove_instance_variable(:@log_level) if instance_variable_defined?( :@log_level ) 
+      remove_instance_variable(:@backtrace_log_level) if instance_variable_defined?( :@backtrace_log_level )      
 
       self.name = @initialized_name
       self.path = @initialized_path_so_far ? @initialized_path_so_far.dup : []
@@ -374,7 +448,7 @@ module Catamaran
 
     def to_s
       # Implicit return
-      "#<#{self.class}:0x#{object_id.to_s(16)}>[name=#{self.name},path=#{path_to_s},depth=#{self.depth},log_level=#{@log_level}]"
+      "#<#{self.class}:0x#{object_id.to_s(16)}>[name=#{self.name},path=#{path_to_s},depth=#{self.depth},log_level=#{@log_level},backtrace_log_level=#{@backtrace_log_level}]"
     end
 
     protected
@@ -413,9 +487,10 @@ module Catamaran
 
 
     ##
-    # All log statements eventually call _log
+    # All log statements eventually call log
+
+    def log( log_level, msg, opts )
 
-    def _log( log_level, msg, opts )
       if self.specified_file || self.specified_class
         opts = {} unless opts
         opts[:file] = self.specified_file if self.specified_file
@@ -423,15 +498,35 @@ module Catamaran
       end
 
       if opts && opts[:backtrace] == true
-        # If backtrace is NOT enabled, then delete it from the options before it gets passed to the formatter
-        if !backtrace?
+        _smart_backtrace_log_level = self.smart_backtrace_log_level()
+
+        # If the specified log message has a level that's 
+        # greater than or equal to the current backtrace_log_level
+        Catamaran.debugging( "Catamaran::Logger#initialize() - Considering a backtrace:  log_level = #{log_level}, backtrace_log_level = #{_smart_backtrace_log_level}" )  if Catamaran.debugging?
+
+
+        if log_level >= _smart_backtrace_log_level
+          # no-op -- display the backtrace
+        else
+          # overwrite opts with a new value
+
+          # For performance it's probably acceptable to just remove the backtrace option from the options list...
+          # opts.delete(:backtrace)
+        
+          # But for now it might be cleaner to duplicate the hash first, before modifying it 
           opts = opts.dup
-          opts.delete(:backtrace)
+          opts.delete( :backtrace )
         end
       end
 
-      formatted_msg = Manager.formatter_class.construct_formatted_message( log_level, self.path_to_s(), msg, opts )
-      Outputter.write( formatted_msg )
+      # Implicit return
+      Outputter.write( _format_msg( log_level, msg, opts ) )
+    end
+
+
+    def _format_msg( log_level, msg, opts )
+      # Implicit return
+      Manager.formatter_class.construct_formatted_message( log_level, self.path_to_s(), msg, opts )
     end
 
     ##

data/lib/catamaran/version.rb

@@ -1,4 +1,4 @@
 module Catamaran
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end
 

data/spec/catamaran_spec.rb

@@ -1,6 +1,10 @@
 require 'spec_helper'
 
 describe Catamaran do
+  before(:each) do
+    Catamaran::Manager.stderr = false
+  end
+
   it "should define TRACE" do
     Catamaran::LogLevel::TRACE.should > 0
   end
@@ -20,11 +24,11 @@ describe Catamaran do
   end  
 
   it "should reuse the same logger instance when contextually the same" do
-    Catamaran.logger.Company.Product.App.Model.User.object_id.should == Catamaran.logger.Company.Product.App.Model.User.object_id
+    Catamaran.logger.com.mycompany.myrailsproject.app.models.User.object_id.should == Catamaran.logger.com.mycompany.myrailsproject.app.models.User.object_id
   end  
 
   it "should reuse the same logger instance when contextually the same regardless of if the logger was determined by a string or by sequential method calls" do
-    Catamaran.logger( "Company.Product.App.Model.User" ).object_id.should == Catamaran.logger.Company.Product.App.Model.User.object_id        
+    Catamaran.logger( "com.mycompany.myrailsproject.app.models.User" ).object_id.should == Catamaran.logger.com.mycompany.myrailsproject.app.models.User.object_id        
   end  
 
   it "should provide access to the root logger through CatLogger" do
@@ -37,9 +41,9 @@ describe Catamaran do
   end
 
   it "should provide access to loggers after a reset" do
-    logger = Catamaran.logger.Company.Product.App.Model.User
+    logger = Catamaran.logger.com.mycompany.myrailsproject.app.models.User
     Catamaran::Manager.reset
-    logger2 = Catamaran.logger.Company.Product.App.Model.User
+    logger2 = Catamaran.logger.com.mycompany.myrailsproject.app.models.User
     logger2.should be_instance_of( Catamaran::Logger )
     logger2.object_id.should == logger.object_id
   end
@@ -47,15 +51,21 @@ describe Catamaran do
   it "should create a new loggers for each point in the path" do
     Catamaran.logger
     Catamaran::Manager.num_loggers.should == 1
-    Catamaran.logger.Company.Product.App.Model.User
-    Catamaran::Manager.num_loggers.should == 6    
+    Catamaran.logger.com.mycompany.myrailsproject.app.models.User
+    Catamaran::Manager.num_loggers.should == 7    
   end     
 
-  it "should be possible for the user to modify the default log level" do
-    Catamaran::LogLevel.default_log_level = Catamaran::LogLevel::TRACE
-    Catamaran.logger.smart_log_level.should == Catamaran::LogLevel::TRACE
+  it "should be possible for the user to modify the log level of root logger" do
+    Catamaran.logger.log_level = Catamaran::LogLevel::TRACE
+    Catamaran.logger.log_level.should == Catamaran::LogLevel::TRACE
   end
 
+  it "should be possible for the user to modify the log level of non-root loggers" do
+    Catamaran.logger.whatever.log_level.should be_nil
+    Catamaran.logger.whatever.log_level = Catamaran::LogLevel::TRACE
+    Catamaran.logger.whatever.log_level.should == Catamaran::LogLevel::TRACE
+  end  
+
   it "should not provide the same object ID for different paths" do
     Catamaran.logger.A.C.object_id.should_not == Catamaran.logger.B.C
     Catamaran.logger.A.C.object_id.should_not == Catamaran.logger.A.B
@@ -63,24 +73,50 @@ describe Catamaran do
 
   context "by default" do
     it "should log INFO messages" do
-      logger = Catamaran.logger.Company.Product.App.Model.User
+      logger = Catamaran.logger.com.mycompany.myrailsproject.app.models.User
     end
 
     it "should NOT log DEBUG messages" do
-      logger = Catamaran.logger.Company.Product.App.Model.User
+      logger = Catamaran.logger.com.mycompany.myrailsproject.app.models.User
     end
 
-    it "should have an INFO log level set for the root logger" do
-      Catamaran.logger.log_level.should == Catamaran::LogLevel::INFO
-    end
+    describe "the Root Logger" do
+      it "should have a log level set to INFO" do
+        Catamaran.logger.log_level.should == Catamaran::LogLevel::INFO
+      end
 
-    it "should have an UNSET log level for any non-root loggers" do
-      Catamaran.logger.log_level = Catamaran::LogLevel::ERROR
-      Catamaran.logger.Test.log_level.should be_nil
+      it "should have a backtrace log level set to WARN" do
+        Catamaran.logger.backtrace_log_level.should == Catamaran::LogLevel::WARN
+      end      
     end
 
-    it "should have one logger configured" do
-      Catamaran::Manager.num_loggers.should == 1
+    describe "a non-root Logger" do
+      before(:each) do
+        @non_root_logger = Catamaran.logger.whatever
+      end
+
+
+      it "should have a log level set to INFO" do
+        @non_root_logger.log_level.should be_nil
+      end
+
+      it "should have a backtrace log level set to WARN" do
+        @non_root_logger.backtrace_log_level.should be_nil
+      end 
+
+      it "should have a smart log level set to INFO" do
+        @non_root_logger.smart_log_level.should == Catamaran::LogLevel::INFO
+      end
+
+      it "should have a smart backtrace log level set to WARN" do
+        @non_root_logger.smart_backtrace_log_level.should == Catamaran::LogLevel::WARN
+      end      
+    end    
+
+    describe "Catamaran::Manager" do
+      it "should have one logger configured" do
+        Catamaran::Manager.num_loggers.should == 1
+      end
     end
 
     it "should have an IO log level that corresponds to IO_LESS_CRITICAL_THAN_INFO" do
@@ -88,28 +124,32 @@ describe Catamaran do
     end
   end
 
-  context "when the log level is set to INFO" do
-    Catamaran.logger.log_level = Catamaran::LogLevel::INFO
-    Catamaran.logger.Company.Product.App.Model.User
-  end
-
   context "after a (soft) reset" do
-    it "should have a default log level of INFO" do
-      logger = Catamaran.logger
-      logger.log_level.should == Catamaran::LogLevel::INFO
-      logger.log_level = Catamaran::LogLevel::ERROR
-      logger.log_level.should == Catamaran::LogLevel::ERROR
-      Catamaran::Manager.reset
-      logger.log_level.should == Catamaran::LogLevel::INFO      
-    end
+    describe "the Root Logger" do
+      it "should have a log level of INFO" do
+        logger = Catamaran.logger
+        logger.log_level = Catamaran::LogLevel::ERROR
+        logger.log_level.should == Catamaran::LogLevel::ERROR
+        Catamaran::Manager.reset
+        logger.log_level.should == Catamaran::LogLevel::INFO      
+      end
+
+      it "should have a backtrace log level of WARN" do
+        logger = Catamaran.logger
+        logger.backtrace_log_level = Catamaran::LogLevel::ERROR
+        logger.backtrace_log_level.should == Catamaran::LogLevel::ERROR
+        Catamaran::Manager.reset
+        logger.backtrace_log_level.should == Catamaran::LogLevel::WARN      
+      end 
+    end   
 
-    it "should keep the number of loggers unchanged" do
+    it "should have the same number of loggers" do
       Catamaran.logger
       Catamaran::Manager.num_loggers.should == 1
-      Catamaran.logger.Company.Product.App.Model.User
-      Catamaran::Manager.num_loggers.should == 6 
+      Catamaran.logger.com.mycompany.myrailsproject.app.models.User
+      Catamaran::Manager.num_loggers.should == 7 
       Catamaran::Manager.reset
-      Catamaran::Manager.num_loggers.should == 6      
+      Catamaran::Manager.num_loggers.should == 7      
     end
 
     it "should have the same root logger object before and after the reset" do
@@ -119,9 +159,9 @@ describe Catamaran do
     end
 
     it "should reuse the same logger non-root logger instance" do
-      before_logger = Catamaran.logger.Company.Product.App.Model.User
+      before_logger = Catamaran.logger.com.mycompany.myrailsproject.app.models.User
       Catamaran::Manager.reset
-      before_logger.object_id.should == Catamaran.logger.Company.Product.App.Model.User.object_id   
+      before_logger.object_id.should == Catamaran.logger.com.mycompany.myrailsproject.app.models.User.object_id   
     end      
   end
 
@@ -138,8 +178,8 @@ describe Catamaran do
     it "should reset the number of loggers to 1" do
       Catamaran.logger
       Catamaran::Manager.num_loggers.should == 1
-      Catamaran.logger.Company.Product.App.Model.User
-      Catamaran::Manager.num_loggers.should == 6 
+      Catamaran.logger.com.mycompany.myrailsproject.app.models.User
+      Catamaran::Manager.num_loggers.should == 7 
       Catamaran::Manager.hard_reset
       Catamaran::Manager.num_loggers.should == 1      
     end
@@ -151,17 +191,44 @@ describe Catamaran do
     end
 
     it "should NOT reuse the same non-root logger instance" do
-      before_logger = Catamaran.logger.Company.Product.App.Model.User
+      before_logger = Catamaran.logger.com.mycompany.myrailsproject.app.models.User
       Catamaran::Manager.hard_reset
-      before_logger.object_id.should_not == Catamaran.logger.Company.Product.App.Model.User.object_id   
+      before_logger.object_id.should_not == Catamaran.logger.com.mycompany.myrailsproject.app.models.User.object_id   
     end     
   end
 
-  describe Catamaran.logger do
-    it "should be able to inherit it's parent's log level" do
-      Catamaran.logger.log_level = Catamaran::LogLevel::ERROR
-      Catamaran.logger.Test.smart_log_level.should == Catamaran::LogLevel::ERROR
-    end  
+  describe "Backtrace Logging" do
+    it "should capture a backtrace when the requested log is DEBUG and the log_level and backtrace_log_level are TRACE" do
+      logger = Catamaran.logger
+      logger.should_receive( :_format_msg ).with( Catamaran::LogLevel::DEBUG, 'message', {:backtrace=>true} )
+      logger.log_level = Catamaran::LogLevel::TRACE
+      logger.backtrace_log_level = Catamaran::LogLevel::TRACE
+      Catamaran.logger.debug( "message", { :backtrace => true } ) if Catamaran.logger.debug?
+    end
+
+    it "should capture a backtrace when the requested log is DEBUG and the log_level and backtrace_log_level are DEBUG" do
+      logger = Catamaran.logger
+      logger.should_receive( :_format_msg ).with( Catamaran::LogLevel::DEBUG, 'message', {:backtrace=>true} )
+      logger.log_level = Catamaran::LogLevel::DEBUG
+      logger.backtrace_log_level = Catamaran::LogLevel::DEBUG
+      Catamaran.logger.debug( "message", { :backtrace => true } ) if Catamaran.logger.debug?
+    end    
+
+    it "should capture a backtrace when the requested log is DEBUG and the log_level is TRACE and the backtrace_log_level is DEBUG" do
+      logger = Catamaran.logger
+      logger.should_receive( :_format_msg ).with( Catamaran::LogLevel::DEBUG, 'message', {:backtrace=>true} )
+      logger.log_level = Catamaran::LogLevel::TRACE
+      logger.backtrace_log_level = Catamaran::LogLevel::DEBUG
+      Catamaran.logger.debug( "message", { :backtrace => true } ) if Catamaran.logger.debug?
+    end
+
+    it "should NOT capture a backtrace when the backtrace_log_level is greater than the level of the log" do
+      logger = Catamaran.logger
+      logger.log_level = Catamaran::LogLevel::TRACE
+      logger.backtrace_log_level = Catamaran::LogLevel::WARN      
+      logger.should_receive( :_format_msg ).with( Catamaran::LogLevel::DEBUG, 'message', {} )
+      Catamaran.logger.debug( "message", { :backtrace => true } ) if Catamaran.logger.debug?
+    end    
   end
 
   describe Catamaran::Manager do
@@ -186,37 +253,42 @@ describe Catamaran do
   end
 
   describe Catamaran::Logger do
+    it "should inherit it's log level (via smart_log_level) from an ancestor" do
+      Catamaran.logger.com.mycompany.myproject.controllers.log_level = Catamaran::LogLevel::ERROR
+      Catamaran.logger.com.mycompany.myproject.controllers.MyController.smart_log_level.should == Catamaran::LogLevel::ERROR
+    end 
+
     it "should inherit the log level from the root logger as needed" do
       Catamaran.logger.smart_log_level.should == Catamaran::LogLevel::INFO
-      Catamaran.logger.Company.Product.App.Model.User.log_level.should be_nil     
-      Catamaran.logger.Company.Product.App.Model.User.smart_log_level.should == Catamaran::LogLevel::INFO
+      Catamaran.logger.com.mycompany.myrailsproject.app.models.User.log_level.should be_nil     
+      Catamaran.logger.com.mycompany.myrailsproject.app.models.User.smart_log_level.should == Catamaran::LogLevel::INFO
     end
 
     it "should have a nil log_level unless explicitly set" do
-      Catamaran.logger.Company.Product.App.Model.User.log_level.should be_nil     
+      Catamaran.logger.com.mycompany.myrailsproject.app.models.User.log_level.should be_nil     
     end
 
     it "should always have a smart_log_level set" do
-      Catamaran.logger.Company.Product.App.Model.User.log_level.should be_nil           
-      Catamaran.logger.Company.Product.App.Model.User.smart_log_level.should_not be_nil
+      Catamaran.logger.whatever.log_level.should be_nil           
+      Catamaran.logger.whatever.smart_log_level.should_not be_nil
     end    
 
-    it "should write the log if the log has sufficient weight" do
+    it "should write the log message if the requested log does not have sufficient weight" do
       Catamaran.logger.smart_log_level.should == Catamaran::LogLevel::INFO
-      Catamaran.logger.should_receive( :_log ).once
+      Catamaran.logger.should_receive( :log ).once
       Catamaran.logger.info( "Testing an INFO log" )
     end
 
-    it "should NOT write the log if the log does NOT have sufficient" do
+    it "should NOT write the log message if the requested log does not have sufficient weight" do
       Catamaran.logger.smart_log_level.should == Catamaran::LogLevel::INFO
       # DEBUG is disabled
-      Catamaran.logger.should_not_receive( :_log )
+      Catamaran.logger.should_not_receive( :log )
       Catamaran.logger.debug( "Testing a DEBUG log" )
     end
 
     describe "#determine_path_and_opts_arguments" do
       it "should return the correct path when one string parameter is specified" do
-        Catamaran.logger.send( :determine_path_and_opts_arguments, "Company.Product.App.Model.User" ).should == [ "Company.Product.App.Model.User", nil ]
+        Catamaran.logger.send( :determine_path_and_opts_arguments, "mycompany.myrailsproject.app.models.User" ).should == [ "mycompany.myrailsproject.app.models.User", nil ]
       end
 
       it "should return the correct opts when one hash parameter is specified" do
@@ -224,19 +296,17 @@ describe Catamaran do
       end      
 
       it "should return the correct path and opts when two parameters are specified" do
-        Catamaran.logger.send( :determine_path_and_opts_arguments, "Company.Product.App.Model.User", {} ).should == [ "Company.Product.App.Model.User", {} ]
+        Catamaran.logger.send( :determine_path_and_opts_arguments, "mycompany.myrailsproject.app.models.User", {} ).should == [ "mycompany.myrailsproject.app.models.User", {} ]
       end      
     end
 
-    context "when using smart_log_level" do
-      it "should inherit the log level from a parent" do
-        Catamaran::LogLevel.default_log_level = Catamaran::LogLevel::INFO
-        Catamaran.logger.Company.Product.App.Model.log_level = Catamaran::LogLevel::ERROR
-        Catamaran.logger.Company.Product.App.Controller.log_level = Catamaran::LogLevel::WARN
-        Catamaran.logger.Company.Product.App.Model.User.smart_log_level.should == Catamaran::LogLevel::ERROR
-        Catamaran.logger.Company.Product.App.Controller.UsersController.smart_log_level.should == Catamaran::LogLevel::WARN
-        Catamaran.logger.Company.Product.App.smart_log_level.should == Catamaran::LogLevel::INFO
-      end
+    it "should inherit the log level (via smart_log_level) from it's ancestors" do
+      Catamaran.logger.log_level = Catamaran::LogLevel::INFO
+      Catamaran.logger.com.mycompany.myrailsproject.app.models.log_level = Catamaran::LogLevel::ERROR
+      Catamaran.logger.com.mycompany.myrailsproject.app.controllers.log_level = Catamaran::LogLevel::WARN
+      Catamaran.logger.com.mycompany.myrailsproject.app.models.User.smart_log_level.should == Catamaran::LogLevel::ERROR
+      Catamaran.logger.com.mycompany.myrailsproject.app.controllers.UsersController.smart_log_level.should == Catamaran::LogLevel::WARN
+      Catamaran.logger.Company.Product.App.smart_log_level.should == Catamaran::LogLevel::INFO
     end
 
     context "when the log level is specified, the default is no longer used" do
@@ -246,5 +316,5 @@ describe Catamaran do
         Catamaran.logger.smart_log_level.should == Catamaran::LogLevel::ERROR
       end
     end
-  end    
-end
+  end # ends describe Catamaran::Logger do
+end  # ends describe Catamaran do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: catamaran
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Jeano
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-26 00:00:00.000000000 Z
+date: 2013-12-27 00:00:00.000000000 Z
 dependencies: []
 description: A logging utility
 email: