catamaran 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e807d462b178ce06016ad76babba6ba142928f9
-  data.tar.gz: 240ed2615b1b49361f3c49ba5be63bf2a5edafa8
+  metadata.gz: dad20818493f3c8f96f0d942495f6a4cb40712e0
+  data.tar.gz: 79168eb79497446d8247b0c1a6b0d017365ea687
 SHA512:
-  metadata.gz: 1214f644cbecf098a31703930f6dfe4aed9715faa88ffa7acfcc8dbc8759e69f14104ff6ce72baa8317f35376ae71a7dd41bce1aad194c53b130c4c76f2132eb
-  data.tar.gz: 784259e5224043161d3b23bea3088e4f8328cd23b36feeabdebaf3f5edbde2b28d41588577aff6d41864f4935aaed8eeb24eeee225856dda61312842a988586d
+  metadata.gz: 30c7a5da926687402aecfbee909a3d1d6aef5f02c49ea4793e1b46891ecf1adda76845ab44a2f52060881c975908b71d14274cc3b9a71d07f237cdfca00812dd
+  data.tar.gz: 86295eff51d438edd6df7e28755c8447e6cd54180739ff4a76682888e69c9d7a97af4fc638492dfb2eba9712e0e9578a5bee9022a1667d8ad1fcad9f71fa6a1e

data/README.md

@@ -6,7 +6,7 @@ Logging is a powerful and often undervalued tool in software development.  When
 Gemfile
 -------
 
-    gem 'catamaran', '~> 0.7.0'
+    gem 'catamaran', '~> 0.8.0'
 
 Rails-related setup:
 
@@ -16,78 +16,84 @@ Now modify `config/initializers/catamaran/development.rb` as needed
 
 Ruby Quickstart
 ---------------
-    require 'catamaran'
+```ruby
+require 'catamaran'
 
-    class FirstRubyDemo
-      LOGGER = Catamaran.logger( "FirstRubyDemo" )
+class FirstRubyDemo
+  LOGGER = Catamaran.logger( "FirstRubyDemo" )
+  # or equivalently: 
+  # LOGGER = Catamaran.logger.FirstRubyDemo
 
-      def run
-        LOGGER.warn( "Note that WARN messages are getting logged" ) if LOGGER.warn?
-        LOGGER.trace( "Note that TRACE messages are NOT getting logged" ) if LOGGER.trace?
-      end
-    end
+  def run
+    LOGGER.notice( "Note that NOTICE messages are captured by default" ) if LOGGER.notice?
+    LOGGER.info( "Note that INFO messages are NOT captured by default" ) if LOGGER.info?
+    LOGGER.debug( "Note that DEBUG messages are NOT captured by default" ) if LOGGER.debug?
+  end
+end
 
-    FirstRubyDemo.new.run
+FirstRubyDemo.new.run
+```
 
 And the output
 
-     WARN pid-2729 [2013-12-23 19:35:35:732]                                   FirstRubyDemo - Note that WARN messages are getting logged
+    NOTICE pid-2729 [2013-12-23 19:35:35:732]                                   FirstRubyDemo - Note that NOTICE messages are getting captured by default
 
 
 Rails Quickstart
 ----------------
 
-    class PagesController < ApplicationController
-      LOGGER = Catamaran.logger.com.mycompany.myrailsapp.app.controllers.PagesController
-
-      def index
-        # LOGGER.io methods are reserved for logs related to entering and returning from methods
-        LOGGER.io "Entering with params = #{params}" if LOGGER.io?
-
-        LOGGER.trace "This is my TRACE log" if LOGGER.trace?
-        LOGGER.debug "This is my DEBUG log" if LOGGER.debug?
-        LOGGER.info "This is my INFO log" if LOGGER.info?
-        LOGGER.warn "This is my WARN log" if LOGGER.warn?
-        LOGGER.error "This is my ERROR log" if LOGGER.error?
+```ruby
+class PagesController < ApplicationController
+  LOGGER = Catamaran.logger.com.mycompany.myrailsapp.app.controllers.PagesController
 
-        LOGGER.io "Returning" if LOGGER.io?        
-      end
-    end
+  def index
+    LOGGER.debug "Entering with params = #{params}" if LOGGER.debug?       
+  end
+end
+```
 
 Load the `index` page and check out your `development.log` file
 
 ### Sample log entry (in your development.log file)
-    IO pid-86000 [2013-12-17 17:26:39:176] pany.myrailsapp.app.controllers.PagesController - Entering with params = {"controller"=>"pages", "action"=>"index"} (`/myrailsapp/app/controllers/pages_controller.rb:7`:in `index`)
+    DEBUG pid-86000 [2013-12-17 17:26:39:176] pany.myrailsapp.app.controllers.PagesController - Entering with params = {"controller"=>"pages", "action"=>"index"} (`/myrailsapp/app/controllers/pages_controller.rb:7`:in `index`)
+
+Log Levels
+----------
+Available log levels:  `TRACE` (verbose and trivial log messages), `DEBUG`, `INFO`, `NOTICE`, `WARN`, `ERROR`, `SEVERE` (logs related to very serious error conditions)
+
+The `NOTICE` log level severity is the default.   Any logs with `NOTICE` or higher severity will be captured.
 
 
 Other Ruby Examples
 -------------------
-    require 'catamaran'
+```ruby
+require 'catamaran'
 
-    Catamaran.logger.log_level = Catamaran::LogLevel::INFO 
-    Catamaran.logger.backtrace_log_level = Catamaran::LogLevel::ERROR 
-    Catamaran::Manager.formatter_class = Catamaran::Formatter::NoCallerFormatter
+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__ } )
+class SecondRubyDemo
+  LOGGER = Catamaran.logger( { :class => name(), :file => __FILE__ } )
 
-      def run
-        LOGGER.info( "Sample INFO statement", { :line => __LINE__, :method => 'run'} ) if LOGGER.info?
-      end
-    end 
+  def run
+    LOGGER.info( "Sample INFO statement", { :line => __LINE__, :method => 'run'} ) if LOGGER.info?
+  end
+end 
 
-    class ThirdRubyDemo
-      LOGGER = Catamaran.logger( "com.mycompany.ThirdRubyDemo", { :class => name(), :file => __FILE__ } )
+class ThirdRubyDemo
+  LOGGER = Catamaran.logger( "com.mycompany.ThirdRubyDemo", { :class => name(), :file => __FILE__ } )
 
-      def run
-        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   
+  def run
+    LOGGER.warn( "Sample WARN statement", { :line => __LINE__, :method => 'run' } )
+    LOGGER.warn( "Sample WARN statement with backtrace option", { :line => __LINE__, :method => 'run', :backtrace => true } )
+    LOGGER.error( "Sample ERROR statement with backtrace option", { :line => __LINE__, :method => 'run', :backtrace => true } )        
+  end
+end   
 
-    SecondRubyDemo.new.run
-    ThirdRubyDemo.new.run
+SecondRubyDemo.new.run
+ThirdRubyDemo.new.run
+```
 
 And the output
 
@@ -115,111 +121,122 @@ I'm looking for a logging utility that:
 * 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
+* http://www.ietf.org/rfc/rfc3164.txt
 
 Performance Considerations
 --------------------------
 
 ### With or without `if LOGGER.debug?`
-    require 'catamaran'
-    require 'benchmark'
+```ruby
+require 'catamaran'
+require 'benchmark'
 
-    Catamaran::LogLevel.default_log_level = Catamaran::LogLevel::INFO 
-    Catamaran::Manager.formatter_class = Catamaran::Formatter::NoCallerFormatter
-    Catamaran::Manager.stderr = false
-
-    class CatamaranPerformanceTest
-      LOGGER = Catamaran.logger( "CatamaranPerformanceTest" )
-
-      # NOTE that the log level for this test is set to INFO, 
-      # so 'warn' logs are enabled and 'debug' logs are disabled
-
-      n = 500000
-      Benchmark.bm(7) do |x|
-        x.report("warn WITHOUT if LOGGER.warn?  ") {
-          n.times do |i|
-            LOGGER.warn "Based on the current log level, this log is being captured"
-          end
-        }
-        x.report("warn WITH if LOGGER.warn?     ") {
-          n.times do |i|
-            LOGGER.warn "Based on the current log level, this log is being captured" if LOGGER.warn?
-          end
-        }
+Catamaran::LogLevel.default_log_level = Catamaran::LogLevel::INFO 
+Catamaran::Manager.formatter_class = Catamaran::Formatter::NoCallerFormatter
+Catamaran::Manager.stderr = false
+
+class CatamaranPerformanceTest
+  LOGGER = Catamaran.logger( "CatamaranPerformanceTest" )
+
+  # NOTE that the log level for this test is set to INFO, 
+  # so 'warn' logs are enabled and 'debug' logs are disabled
+
+  n = 500000
+  Benchmark.bm(7) do |x|
+    x.report("warn WITHOUT if LOGGER.warn?  ") {
+      n.times do |i|
+        LOGGER.warn "Based on the current log level, this log is being captured"
+      end
+    }
+    x.report("warn WITH if LOGGER.warn?     ") {
+      n.times do |i|
+        LOGGER.warn "Based on the current log level, this log is being captured" if LOGGER.warn?
+      end
+    }
+  end
+
+  Benchmark.bm(7) do |x|
+    x.report("debug WITHOUT if LOGGER.debug?") {
+      n.times do |i|
+        LOGGER.debug "Based on the current log level, this log is NOT being captured"
+      end
+    }
+    x.report("debug WITH if LOGGER.debug?   ") {
+      n.times do |i|
+        LOGGER.debug "Based on the current log level, this log is NOT being captured" if LOGGER.debug?       
       end
+    }
+  end 
+
+end
 
-      Benchmark.bm(7) do |x|
-        x.report("debug WITHOUT if LOGGER.debug?") {
-          n.times do |i|
-            LOGGER.debug "Based on the current log level, this log is NOT being captured"
-          end
-        }
-        x.report("debug WITH if LOGGER.debug?   ") {
-          n.times do |i|
-            LOGGER.debug "Based on the current log level, this log is NOT being captured" if LOGGER.debug?       
-          end
-        }
-      end 
-
-    end
-
-    #                                     user     system      total        real
-    # warn WITHOUT if LOGGER.warn?    6.940000   0.010000   6.950000 (  6.950691)
-    # warn WITH if LOGGER.warn?       7.650000   0.000000   7.650000 (  7.658004)
-    #                                     user     system      total        real
-    # debug WITHOUT if LOGGER.debug?  0.660000   0.010000   0.670000 (  0.665775)
-    # debug WITH if LOGGER.debug?     0.560000   0.010000   0.570000 (  0.574397)
+#                                     user     system      total        real
+# warn WITHOUT if LOGGER.warn?    6.940000   0.010000   6.950000 (  6.950691)
+# warn WITH if LOGGER.warn?       7.650000   0.000000   7.650000 (  7.658004)
+#                                     user     system      total        real
+# debug WITHOUT if LOGGER.debug?  0.660000   0.010000   0.670000 (  0.665775)
+# debug WITH if LOGGER.debug?     0.560000   0.010000   0.570000 (  0.574397)
+```
 
 #### Summary
 
-* For log messages that are usually *disabled* in the production environment ( TRACE, DEBUG ), it's generally better to invoke the log only after confirming that the log level is enabled 
+* For log messages that are usually *disabled* in the production environment ( TRACE, DEBUG, INFO ), it's generally better to invoke the log only after confirming that the log level is enabled 
 
 ex:
 
-    LOGGER.trace "This is a TRACE log" if LOGGER.trace?
-    LOGGER.debug "This is a DEBUG log" if LOGGER.debug?
+```ruby
+LOGGER.trace "This is a TRACE log" if LOGGER.trace?
+LOGGER.debug "This is a DEBUG log" if LOGGER.debug?
+LOGGER.info "This is a INFO log" if LOGGER.info?
+```
 
-* For log messages that are usually *enabled* in the production environment ( INFO, WARN, ERROR, SEVERE ), it's generally better to invoke the log WITHOUT first testing the log level
+* For log messages that are usually *enabled* in the production environment ( NOTICE, WARN, ERROR, SEVERE ), it's generally better to invoke the log WITHOUT first testing the log level
 
 ex:
 
-    LOGGER.info "This is a INFO log"
-    LOGGER.warn "This is a WARN log"
-    LOGGER.error "This is a ERROR log" 
+```ruby
+LOGGER.notice "This is a NOTICE log"
+LOGGER.warn "This is a WARN log"
+LOGGER.error "This is a ERROR log" 
+LOGGER.severe "This is a SEVERE log" 
+```
 
 ### NoCallerFormatter vs CallerFormatter
 
-    require 'catamaran'
-    require 'benchmark'
-
-    Catamaran::Manager.stderr = false
-
-    class CatamaranPerformanceTest
-      LOGGER = Catamaran.logger( "CatamaranPerformanceTest" )
-
-      n = 500000
-      Benchmark.bm(7) do |x|
-        Catamaran::Manager.formatter_class = Catamaran::Formatter::NoCallerFormatter
-        
-        x.report("Using NoCallerFormatter") {
-          n.times do |i|
-            LOGGER.error "This is a ERROR log"
-          end
-        }   
-        
-        Catamaran::Manager.formatter_class = Catamaran::Formatter::CallerFormatter
-        
-        x.report("Using CallerFormatter") {
-          n.times do |i|
-            LOGGER.error "This is a ERROR log"
-          end
-        }
+```ruby
+require 'catamaran'
+require 'benchmark'
+
+Catamaran::Manager.stderr = false
+
+class CatamaranPerformanceTest
+  LOGGER = Catamaran.logger( "CatamaranPerformanceTest" )
+
+  n = 500000
+  Benchmark.bm(7) do |x|
+    Catamaran::Manager.formatter_class = Catamaran::Formatter::NoCallerFormatter
+    
+    x.report("Using NoCallerFormatter") {
+      n.times do |i|
+        LOGGER.error "This is a ERROR log"
+      end
+    }   
+    
+    Catamaran::Manager.formatter_class = Catamaran::Formatter::CallerFormatter
+    
+    x.report("Using CallerFormatter") {
+      n.times do |i|
+        LOGGER.error "This is a ERROR log"
       end
-    end
-                             
+    }
+  end
+end
+                         
 
-    #                              user     system      total        real
-    # Using NoCallerFormatter  6.850000   0.010000   6.860000 (  6.864649)
-    # Using CallerFormatter   14.700000   0.150000  14.850000 ( 14.867592)
+#                              user     system      total        real
+# Using NoCallerFormatter  6.850000   0.010000   6.860000 (  6.864649)
+# Using CallerFormatter   14.700000   0.150000  14.850000 ( 14.867592)
+```
 
 #### Summary
 
@@ -246,7 +263,8 @@ Ideas around what's next
 * Something like `filter_parameter_logging`
 * Color support
 * Log rotation
-* Heroku support
+* Heroku support (https://blog.heroku.com/archives/2013/7/15/logging-on-heroku)
+* Buffered file I/O considerations
 
 
 

data/lib/catamaran/formatter/base_formatter.rb

@@ -4,7 +4,7 @@ module Catamaran
     # Construct a properly formatted log message based
 
     class BaseFormatter
-      def self.base_construct_formatted_message( log_level, path, msg, opts )
+      def self.base_construct_formatted_message( severity, path, msg, opts )
         # Truncate on the left
         if path.length > 47
           updated_path = path.dup[-47,47]
@@ -14,7 +14,7 @@ module Catamaran
 
         # TODO:  Abstract out the logger so that it's easy to use different formats
         # Implicit return
-        retval = sprintf( "%6s pid-#{Process.pid} [#{Time.now.strftime( "%G-%m-%d %H:%M:%S:%L" )}] %47s - #{msg}", LogLevel.to_s(log_level), updated_path  )
+        retval = sprintf( "%6s pid-#{Process.pid} [#{Time.now.strftime( "%G-%m-%d %H:%M:%S:%L" )}] %47s - #{msg}", LogLevel.severity_to_s( severity ), updated_path  )
       end
 
       def self.construct_backtrace_info( opts )

data/lib/catamaran/log_level.rb

@@ -4,18 +4,24 @@ module Catamaran
     # If that's too verbose, the level can be changed to IO_LESS_CRITICAL_THAN_DEBUG and logger.io messages won't be
     # visible unless the log level is set to TRACE.  
     # See development.rb for an example of this
-    IO_LESS_CRITICAL_THAN_DEBUG = 2080
-    IO_LESS_CRITICAL_THAN_INFO = 3080
+    IO_LESS_CRITICAL_THAN_DEBUG = 2780
+    IO_LESS_CRITICAL_THAN_INFO = 3780
+    IO_LESS_CRITICAL_THAN_NOTICE = 4780
 
     ALL = 100
 
     TRACE = 2000 
     DEBUG = 3000
     INFO = 4000
-    WARN = 5000
-    ERROR = 6000
-    SEVERE = 7000
-    FATAL = 8000
+    # Adding notice per http://www.faqs.org/rfcs/rfc3164.html
+    NOTICE = 5000  
+    WARN = 6000
+    ERROR = 7000
+    SEVERE = 8000  # versus critical
+    
+    # FATAL is currently unused.  In logger.rb you can see the fatal-related methods are commented out
+    FATAL = 9000   # versus alert
+                   # versus emergency
 
     IO = IO_LESS_CRITICAL_THAN_INFO
 
@@ -27,29 +33,31 @@ module Catamaran
     self.reset()
     
 
-    def self.to_s( log_level )
-      case log_level
+    def self.severity_to_s( severity )
+      case severity
       when TRACE
-        retval = 'TRACE'
+        'TRACE'
       when DEBUG
-        retval = 'DEBUG'
+        'DEBUG'
       when INFO
-        retval = 'INFO'
+        'INFO'
+      when NOTICE
+        'NOTICE'
       when WARN
-        retval = 'WARN'
+        'WARN'
       when ERROR
-        retval =  'ERROR'
+        'ERROR'
       when SEVERE
-        retval =  'SEVERE'
+        'SEVERE'
       when FATAL
-        retval =  'FATAL'
+        'FATAL'
       when IO_LESS_CRITICAL_THAN_INFO
-        retval =  'IO'
+        'IO'
       when IO_LESS_CRITICAL_THAN_DEBUG
-        retval =  'IO'
+        'IO'
+      else
+        'UNKNOWN'
       end
-
-      retval
     end   
 
     def self.log_level_io=( value )

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::INFO
+        retval = Catamaran::LogLevel::NOTICE
       else
         recursive = opts[:recursive]
         if recursive == true 
@@ -202,6 +202,23 @@ module Catamaran
       end
     end 
 
+    ##
+    # Is notice-level logging currently enabled?
+
+    def notice?
+      if self.smart_log_level() <= LogLevel::NOTICE
+        true
+      else
+        false
+      end
+    end
+
+    def notice( msg, opts = nil )
+      if notice?
+        log( LogLevel::NOTICE, msg, opts )
+      end
+    end    
+
     ##
     # Is warn-level logging currently enabled?
 
@@ -489,7 +506,7 @@ module Catamaran
     ##
     # All log statements eventually call log
 
-    def log( log_level, msg, opts )
+    def log( severity, msg, opts )
 
       if self.specified_file || self.specified_class
         opts = {} unless opts
@@ -502,10 +519,10 @@ module Catamaran
 
         # 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?
+        Catamaran.debugging( "Catamaran::Logger#initialize() - Considering a backtrace:  severity = #{severity}, backtrace_log_level = #{_smart_backtrace_log_level}" )  if Catamaran.debugging?
 
 
-        if log_level >= _smart_backtrace_log_level
+        if severity >= _smart_backtrace_log_level
           # no-op -- display the backtrace
         else
           # overwrite opts with a new value
@@ -520,13 +537,13 @@ module Catamaran
       end
 
       # Implicit return
-      Outputter.write( _format_msg( log_level, msg, opts ) )
+      Outputter.write( _format_msg( severity, msg, opts ) )
     end
 
 
-    def _format_msg( log_level, msg, opts )
+    def _format_msg( severity, msg, opts )
       # Implicit return
-      Manager.formatter_class.construct_formatted_message( log_level, self.path_to_s(), msg, opts )
+      Manager.formatter_class.construct_formatted_message( severity, self.path_to_s(), msg, opts )
     end
 
     ##

data/lib/catamaran/version.rb

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

data/spec/catamaran_spec.rb

@@ -81,8 +81,8 @@ describe Catamaran do
     end
 
     describe "the Root Logger" do
-      it "should have a log level set to INFO" do
-        Catamaran.logger.log_level.should == Catamaran::LogLevel::INFO
+      it "should have a log level set to NOTICE" do
+        Catamaran.logger.log_level.should == Catamaran::LogLevel::NOTICE
       end
 
       it "should have a backtrace log level set to WARN" do
@@ -96,7 +96,7 @@ describe Catamaran do
       end
 
 
-      it "should have a log level set to INFO" do
+      it "should have an empty log level" do
         @non_root_logger.log_level.should be_nil
       end
 
@@ -104,8 +104,8 @@ describe Catamaran 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
+      it "should have a smart log level set to NOTICE" do
+        @non_root_logger.smart_log_level.should == Catamaran::LogLevel::NOTICE
       end
 
       it "should have a smart backtrace log level set to WARN" do
@@ -126,12 +126,12 @@ describe Catamaran do
 
   context "after a (soft) reset" do
     describe "the Root Logger" do
-      it "should have a log level of INFO" do
+      it "should have a log level of NOTICE" 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      
+        logger.log_level.should == Catamaran::LogLevel::NOTICE      
       end
 
       it "should have a backtrace log level of WARN" do
@@ -166,13 +166,13 @@ describe Catamaran do
   end
 
   context "after a hard reset" do
-    it "should have a default log level of INFO" do
+    it "should have a default log level of NOTICE" do
       logger = Catamaran.logger
-      logger.log_level.should == Catamaran::LogLevel::INFO
+      logger.log_level.should == Catamaran::LogLevel::NOTICE
       logger.log_level = Catamaran::LogLevel::ERROR
       logger.log_level.should == Catamaran::LogLevel::ERROR
       Catamaran::Manager.hard_reset
-      logger.log_level.should == Catamaran::LogLevel::INFO      
+      logger.log_level.should == Catamaran::LogLevel::NOTICE      
     end
 
     it "should reset the number of loggers to 1" do
@@ -222,7 +222,7 @@ describe Catamaran do
       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
+    it "should NOT capture a backtrace when the backtrace_log_level is greater than the severity of the log" do
       logger = Catamaran.logger
       logger.log_level = Catamaran::LogLevel::TRACE
       logger.backtrace_log_level = Catamaran::LogLevel::WARN      
@@ -259,9 +259,9 @@ describe Catamaran do
     end 
 
     it "should inherit the log level from the root logger as needed" do
-      Catamaran.logger.smart_log_level.should == Catamaran::LogLevel::INFO
+      root_log_level = Catamaran.logger.smart_log_level      
       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
+      Catamaran.logger.com.mycompany.myrailsproject.app.models.User.smart_log_level.should == root_log_level
     end
 
     it "should have a nil log_level unless explicitly set" do
@@ -273,17 +273,16 @@ describe Catamaran do
       Catamaran.logger.whatever.smart_log_level.should_not be_nil
     end    
 
-    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
+    it "should write the log message if the requested log does have sufficient severity" do
+      Catamaran.logger.smart_log_level.should <= Catamaran::LogLevel::NOTICE
       Catamaran.logger.should_receive( :log ).once
-      Catamaran.logger.info( "Testing an INFO log" )
+      Catamaran.logger.notice( "A NOTICE log should be received" )
     end
 
-    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
+    it "should NOT write the log message if the requested log does not have sufficient severity" do
+      Catamaran.logger.smart_log_level.should > Catamaran::LogLevel::DEBUG
       Catamaran.logger.should_not_receive( :log )
-      Catamaran.logger.debug( "Testing a DEBUG log" )
+      Catamaran.logger.debug( "And INFO log should NOT be received" )
     end
 
     describe "#determine_path_and_opts_arguments" do
@@ -310,11 +309,25 @@ describe Catamaran do
     end
 
     context "when the log level is specified, the default is no longer used" do
-      it "should be " do
-        Catamaran.logger.smart_log_level.should == Catamaran::LogLevel::INFO
+      it "should makeuse of the specified log level rather than the inherited one" do
+        initial_log_level = Catamaran.logger.smart_log_level
         Catamaran.logger.log_level = Catamaran::LogLevel::ERROR
+        initial_log_level.should_not == Catamaran.logger.smart_log_level
         Catamaran.logger.smart_log_level.should == Catamaran::LogLevel::ERROR
       end
     end
   end # ends describe Catamaran::Logger do
+
+  describe Catamaran::LogLevel do
+    describe ".severity_to_s" do
+      it "should be able to convert a numeric log level into a string" do
+        Catamaran::LogLevel.severity_to_s( Catamaran::LogLevel::NOTICE ).should == 'NOTICE'
+      end
+
+      it "should be able to handle IO log levels" do
+        Catamaran::LogLevel.severity_to_s( Catamaran::LogLevel::IO_LESS_CRITICAL_THAN_INFO ).should == 'IO'
+        Catamaran::LogLevel.severity_to_s( Catamaran::LogLevel::IO_LESS_CRITICAL_THAN_DEBUG ).should == 'IO'
+      end
+    end
+  end
 end  # ends describe Catamaran do

metadata

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