hatchet 0.2.1 → 0.2.2

data/README.md

@@ -5,7 +5,8 @@ filters.
 
 This README provides a brief overview of Hatchet, [see the main site for more complete documentation and tutorials](http://gshutler.github.com/hatchet/).
 
-[![Build Status](https://secure.travis-ci.org/gshutler/hatchet.png?branch=master)](http://travis-ci.org/gshutler/hatchet)
+[![Build Status](https://secure.travis-ci.org/gshutler/hatchet.png?branch=master)](http://travis-ci.org/gshutler/hatchet)  
+[![Code Climate](https://codeclimate.com/github/gshutler/hatchet.png)](https://codeclimate.com/github/gshutler/hatchet)
 
 ## Installation
 

data/lib/hatchet/configuration.rb

@@ -16,6 +16,7 @@ module Hatchet
     # Creates the levels Hash with a default logging level of info.
     #
     def initialize
+      @formatter = nil
       reset!
     end
 

data/lib/hatchet/hatchet_logger.rb

@@ -79,57 +79,194 @@ module Hatchet
       @ndc = ndc
     end
 
-    [:debug, :info, :warn, :error, :fatal].each do |level|
-
-      # Public: Logs a message at the given level.
-      #
-      # message - An already evaluated message, usually a String (default: nil).
-      # error   - An error which is associated with the message (default: nil).
-      # block   - An optional block which will provide a message when invoked.
-      #
-      # One of message or block must be provided. If both are provided then the
-      # block is preferred as it is assumed to provide more detail.
-      #
-      # In general, you should use the block style for any message not related
-      # to an error. This is because any unneccessary String interpolation is
-      # avoided making unwritten debug calls, for example, less expensive.
-      #
-      # When logging errors it is advised that you include some details of the
-      # error within the regular message, perhaps the error's message, but leave
-      # the inclusion of the stack trace up to your appenders and their
-      # formatters.
-      #
-      # Examples
-      #
-      #   debug { "A fine grained message" }
-      #   info  { "An interesting message" }
-      #   warn  { "A message worth highlighting" }
-      #   error "A message relating to an exception", e
-      #   fatal "A message causing application failure", e
-      #
-      # Returns nothing.
-      #
-      define_method level do |message = nil, error = nil, &block|
-        return unless message or block
-        add level, Message.new(ndc: @ndc.context.clone, message: message, error: error, &block)
-      end
+    # Public: Logs a message at debug level.
+    #
+    # message - An already evaluated message, usually a String (default: nil).
+    # error   - An error which is associated with the message (default: nil).
+    # block   - An optional block which will provide a message when invoked.
+    #
+    # One of message or block must be provided. If both are provided then the
+    # block is preferred as it is assumed to provide more detail.
+    #
+    # In general, you should use the block style for any message not related
+    # to an error. This is because any unneccessary String interpolation is
+    # avoided making unwritten debug calls, for example, less expensive.
+    #
+    # When logging errors it is advised that you include some details of the
+    # error within the regular message, perhaps the error's message, but leave
+    # the inclusion of the stack trace up to your appenders and their
+    # formatters.
+    #
+    # Examples
+    #
+    #   debug { "A fine grained message" }
+    #   debug "A message relating to an exception", e
+    #
+    # Returns nothing.
+    #
+    def debug(message = nil, error = nil, &block)
+      add(:debug, message, error, &block)
+    end
 
-      # Public: Returns true if any of the appenders will log messages for the
-      # current context, otherwise returns false.
-      #
-      # Writes messages to STDOUT if any appender fails to complete the check.
-      #
-      define_method "#{level}?" do
-        @appenders.any? do |appender|
-          begin
-            appender.enabled? level, @context
-          rescue => e
-            puts "Failed to check if level #{level} enabled for #{context} with appender #{appender}\n"
-            false
-          end
-        end
-      end
+    # Public: Returns true if any of the appenders will log messages for the
+    # current context at debug level, otherwise returns false.
+    #
+    # Writes messages to STDOUT if any appender fails to complete the check.
+    #
+    def debug?
+      enabled? :debug
+    end
+
+    # Public: Logs a message at info level.
+    #
+    # message - An already evaluated message, usually a String (default: nil).
+    # error   - An error which is associated with the message (default: nil).
+    # block   - An optional block which will provide a message when invoked.
+    #
+    # One of message or block must be provided. If both are provided then the
+    # block is preferred as it is assumed to provide more detail.
+    #
+    # In general, you should use the block style for any message not related
+    # to an error. This is because any unneccessary String interpolation is
+    # avoided making unwritten info calls, for example, less expensive.
+    #
+    # When logging errors it is advised that you include some details of the
+    # error within the regular message, perhaps the error's message, but leave
+    # the inclusion of the stack trace up to your appenders and their
+    # formatters.
+    #
+    # Examples
+    #
+    #   info { "A fine grained message" }
+    #   info "A message relating to an exception", e
+    #
+    # Returns nothing.
+    #
+    def info(message = nil, error = nil, &block)
+      add(:info, message, error, &block)
+    end
+
+    # Public: Returns true if any of the appenders will log messages for the
+    # current context at info level, otherwise returns false.
+    #
+    # Writes messages to STDOUT if any appender fails to complete the check.
+    #
+    def info?
+      enabled? :info
+    end
+
+    # Public: Logs a message at warn level.
+    #
+    # message - An already evaluated message, usually a String (default: nil).
+    # error   - An error which is associated with the message (default: nil).
+    # block   - An optional block which will provide a message when invoked.
+    #
+    # One of message or block must be provided. If both are provided then the
+    # block is preferred as it is assumed to provide more detail.
+    #
+    # In general, you should use the block style for any message not related
+    # to an error. This is because any unneccessary String interpolation is
+    # avoided making unwritten warn calls, for example, less expensive.
+    #
+    # When logging errors it is advised that you include some details of the
+    # error within the regular message, perhaps the error's message, but leave
+    # the inclusion of the stack trace up to your appenders and their
+    # formatters.
+    #
+    # Examples
+    #
+    #   warn { "A fine grained message" }
+    #   warn "A message relating to an exception", e
+    #
+    # Returns nothing.
+    #
+    def warn(message = nil, error = nil, &block)
+      add(:warn, message, error, &block)
+    end
 
+    # Public: Returns true if any of the appenders will log messages for the
+    # current context at warn level, otherwise returns false.
+    #
+    # Writes messages to STDOUT if any appender fails to complete the check.
+    #
+    def warn?
+      enabled? :warn
+    end
+
+    # Public: Logs a message at error level.
+    #
+    # message - An already evaluated message, usually a String (default: nil).
+    # error   - An error which is associated with the message (default: nil).
+    # block   - An optional block which will provide a message when invoked.
+    #
+    # One of message or block must be provided. If both are provided then the
+    # block is preferred as it is assumed to provide more detail.
+    #
+    # In general, you should use the block style for any message not related
+    # to an error. This is because any unneccessary String interpolation is
+    # avoided making unwritten error calls, for example, less expensive.
+    #
+    # When logging errors it is advised that you include some details of the
+    # error within the regular message, perhaps the error's message, but leave
+    # the inclusion of the stack trace up to your appenders and their
+    # formatters.
+    #
+    # Examples
+    #
+    #   error { "A fine grained message" }
+    #   error "A message relating to an exception", e
+    #
+    # Returns nothing.
+    #
+    def error(message = nil, error = nil, &block)
+      add(:error, message, error, &block)
+    end
+
+    # Public: Returns true if any of the appenders will log messages for the
+    # current context at error level, otherwise returns false.
+    #
+    # Writes messages to STDOUT if any appender fails to complete the check.
+    #
+    def error?
+      enabled? :error
+    end
+
+    # Public: Logs a message at fatal level.
+    #
+    # message - An already evaluated message, usually a String (default: nil).
+    # error   - An error which is associated with the message (default: nil).
+    # block   - An optional block which will provide a message when invoked.
+    #
+    # One of message or block must be provided. If both are provided then the
+    # block is preferred as it is assumed to provide more detail.
+    #
+    # In general, you should use the block style for any message not related
+    # to an error. This is because any unneccessary String interpolation is
+    # avoided making unwritten fatal calls, for example, less expensive.
+    #
+    # When logging errors it is advised that you include some details of the
+    # error within the regular message, perhaps the error's message, but leave
+    # the inclusion of the stack trace up to your appenders and their
+    # formatters.
+    #
+    # Examples
+    #
+    #   fatal { "A fine grained message" }
+    #   fatal "A message relating to an exception", e
+    #
+    # Returns nothing.
+    #
+    def fatal(message = nil, error = nil, &block)
+      add(:fatal, message, error, &block)
+    end
+
+    # Public: Returns true if any of the appenders will log messages for the
+    # current context at fatal level, otherwise returns false.
+    #
+    # Writes messages to STDOUT if any appender fails to complete the check.
+    #
+    def fatal?
+      enabled? :fatal
     end
 
     # Public: Returns the default level of the logger's configuration.
@@ -173,19 +310,26 @@ module Hatchet
     #
     # message - The message that will be logged by an appender when it is
     #           configured to log at the given level or lower.
+    # error   - An error which is associated with the message.
+    # block   - An optional block which will provide a message when invoked.
+    #
     #
     # Writes messages to STDOUT if any appender fails to complete the enabled
     # check or log the message.
     #
     # Returns nothing.
     #
-    def add(level, message)
+    def add(level, message, error, &block)
+      return unless message or block
+
+      msg = Message.new(ndc: @ndc.context.clone, message: message, error: error, &block)
+
       @appenders.each do |appender|
         if appender.enabled?(level, @context)
           begin
-            appender.add(level, @context, message)
+            appender.add(level, @context, msg)
           rescue => e
-            puts "Failed to log message for #{@context} with appender #{appender} - #{level} - #{message}\n"
+            puts "Failed to log message for #{@context} with appender #{appender} - #{level} - #{msg}\n"
             puts "#{e}\n"
           end
         end
@@ -193,6 +337,31 @@ module Hatchet
       nil
     end
 
+    # Private: Returns true if any of the appenders will log messages for the
+    # current context at the given level, otherwise returns false.
+    #
+    # level   - The level of the message. One of, in decreasing order of
+    #           severity:
+    #
+    #             * fatal
+    #             * error
+    #             * warn
+    #             * info
+    #             * debug
+    #
+    # Writes messages to STDOUT if any appender fails to complete the check.
+    #
+    def enabled?(level)
+      @appenders.any? do |appender|
+        begin
+          appender.enabled? level, @context
+        rescue => e
+          puts "Failed to check if level #{level} enabled for #{context} with appender #{appender}\n"
+          false
+        end
+      end
+    end
+
     # Private: Determines the contextual name of the host object.
     #
     # host - The object hosting this logger.

data/lib/hatchet/level_manager.rb

@@ -60,17 +60,12 @@ module Hatchet
     # level within the given context, otherwise returns false.
     #
     def enabled?(level, context)
-      unless self.levels_cache.key? context
-        lvl = self.levels_cache[nil]
-        root = []
-        context.to_s.split('::').each do |part|
-          root << part
-          path = root.join '::'
-          lvl = self.levels_cache[path] if self.levels_cache.key? path
-        end
-        self.levels_cache[context] = lvl
-      end
-      LEVELS.index(level) >= LEVELS.index(self.levels_cache[context])
+      lvl = self.levels_cache[context]
+
+      # Return false if no level is configured.
+      return false unless lvl
+
+      LEVELS.index(level) >= LEVELS.index(lvl)
     end
 
     # Internal: Returns a lazily duplicated Hash from the levels Hash which is
@@ -78,7 +73,13 @@ module Hatchet
     # subsequent lookups more efficient.
     #
     def levels_cache
-      @_levels_cache ||= self.levels.dup
+      @_levels_cache ||= begin
+        levels = Hash.new do |hash, key|
+          hash[key] = level_for_context(key)
+        end
+        self.levels.each { |k, v| levels[k] = v }
+        levels
+      end
     end
 
     # Internal: Removes the caching Hash so that it will be re-initialized.
@@ -90,6 +91,26 @@ module Hatchet
       @_levels_cache = nil
     end
 
+    private
+
+    # Private: Returns the minimum active logging level for the given context.
+    #
+    # context - The context of the logging call.
+    #
+    # Returns the minimum level that a message would be logged at for the given
+    # context.
+    #
+    def level_for_context(context)
+      lvl = self.levels_cache[nil]
+      root = []
+      context.to_s.split('::').each do |part|
+        root << part
+        path = root.join '::'
+        lvl = self.levels_cache[path] if self.levels_cache.key? path
+      end
+      lvl
+    end
+
   end
 
 end

data/lib/hatchet/plain_formatter.rb

@@ -10,6 +10,12 @@ module Hatchet
   class PlainFormatter
     include BacktraceFormatter
 
+    # Public: Initialize a new instance.
+    #
+    def initialize
+      @backtrace = true
+    end
+
     # Public: Returns the formatted message.
     #
     # level   - The severity of the log message.

data/lib/hatchet/railtie.rb

@@ -27,22 +27,71 @@ module Hatchet
     # collection on initialization.
     #
     initializer 'hatchet_railtie.replace_logger' do |app|
+      Railtie.wrap_rails_logger(app)
+    end
+
+    # Internal: Class method to encapsulate the replacement of the Rails logger
+    # with Hatchet.
+    #
+    def self.wrap_rails_logger(app)
+      initialize_hatchet(Rails.logger)
+      replace_rails_loggers(app)
+    end
+
+    private
 
-      # Keep a handle to the original logger.
+    def self.replace_rails_loggers(app)
+      # Replace the Rails.logger with the application's Hatchet logger.
+      #
+      Rails.logger = app.logger
+      app.logger.debug { 'Replaced Rails logger with Hatchet' }
+
+      # Replace the logger of every subscriber in the
+      # ActiveSupport::LogSubscriber.log_subscribers collection by extending
+      # them with Hatchet.
+      #
+      ActiveSupport::LogSubscriber.log_subscribers.each do |subscriber|
+        app.logger.debug { "Replacing #{subscriber.class} logger with Hatchet" }
+        subscriber.extend Hatchet
+      end
+
+      # Replace the Rails.application.assets.logger with a logger that lives
+      # in a module beneath the application. This allows you to target the
+      # asset logger messages directly when managing levels.
+      #
+      # As you can guess by the description this is probably the riskiest so
+      # we do it last.
       #
-      logger = Rails.logger
+      app.logger.debug { 'Replacing Rails asset logger with Hatchet' }
 
+      wrap_asset_logging(app)
+    rescue
+      # If anything goes wrong along the way log it and let the application
+      # continue.
+      #
+      Rails.logger.error { 'Failed to replace logger with Hatchet' }
+      Rails.logger.error { $! }
+    end
+
+    def self.wrap_asset_logging(app)
+      # Initially replace it with the application logger as it's better for
+      # this to be done if the next part fails.
+      #
+      Rails.application.assets.logger = app.logger
+
+      # Create the <Application>::Assets module and extend it with Hatchet so
+      # that it can replace the assets logger.
+      #
+      assets = Module.new
+      app.class.const_set 'Assets', assets
+      assets.extend Hatchet
+      Rails.application.assets.logger = assets.logger
+    end
+
+    def self.initialize_hatchet(logger)
       # Map the level of the logger so Hatchet uses the same.
       #
-      current_level =
-        case logger.level
-        when Logger::DEBUG then :debug
-        when Logger::INFO  then :info
-        when Logger::WARN  then :warn
-        when Logger::ERROR then :error
-        when Logger::FATAL then :fatal
-        else nil # If not recognized use Hatchet's default
-        end
+      current_level = logger_level(logger)
 
       # Add an appender that delegates to the current Rails.logger to Hatchet's
       # configuration.
@@ -55,52 +104,19 @@ module Hatchet
       # Extend the application with Hatchet.
       #
       app.extend Hatchet
+    end
 
-      begin
-        # Replace the Rails.logger with the application's Hatchet logger.
-        #
-        Rails.logger = app.logger
-        app.logger.debug { 'Replaced Rails logger with Hatchet' }
-
-        # Replace the logger of every subscriber in the
-        # ActiveSupport::LogSubscriber.log_subscribers collection by extending
-        # them with Hatchet.
-        #
-        ActiveSupport::LogSubscriber.log_subscribers.each do |subscriber|
-          app.logger.debug { "Replacing #{subscriber.class} logger with Hatchet" }
-          subscriber.extend Hatchet
-        end
-
-        # Replace the Rails.application.assets.logger with a logger that lives
-        # in a module beneath the application. This allows you to target the
-        # asset logger messages directly when managing levels.
-        #
-        # As you can guess by the description this is probably the riskiest so
-        # we do it last.
-        #
-        app.logger.debug { 'Replacing Rails asset logger with Hatchet' }
-
-        # Initially replace it with the application logger as it's better for
-        # this to be done if the next part fails.
-        #
-        Rails.application.assets.logger = app.logger
-
-        # Create the <Application>::Assets module and extend it with Hatchet so
-        # that it can replace the assets logger.
-        #
-        assets = Module.new
-        app.class.const_set 'Assets', assets
-        assets.extend Hatchet
-        Rails.application.assets.logger = assets.logger
-
-      rescue
-        # If anything goes wrong along the way log it and let the application
-        # continue.
-        #
-        logger.error { 'Failed to replace logger with Hatchet' }
-        logger.error { $! }
+    def self.logger_level(logger)
+      case logger.level
+      when Logger::DEBUG then :debug
+      when Logger::INFO  then :info
+      when Logger::WARN  then :warn
+      when Logger::ERROR then :error
+      when Logger::FATAL then :fatal
+      else nil # If not recognized use Hatchet's default
       end
     end
+
   end
 
 end

data/lib/hatchet/simple_formatter.rb

@@ -14,6 +14,12 @@ module Hatchet
     #
     attr_accessor :thread_context
 
+    # Public: Initialize a new instance.
+    #
+    def initialize
+      @backtrace = true
+    end
+
     # Public: Returns the formatted message.
     #
     # level   - The severity of the log message.

data/lib/hatchet/standard_formatter.rb

@@ -11,7 +11,9 @@ module Hatchet
     # Public: Creates a new instance.
     #
     def initialize
+      @backtrace = true
       @secs = 0
+      @millis = -1
       @level_cache = {}
     end
 

data/lib/hatchet/version.rb

@@ -4,6 +4,6 @@ module Hatchet
 
   # Public: The version of Hatchet.
   #
-  VERSION = '0.2.1'
+  VERSION = '0.2.2'
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hatchet
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-14 00:00:00.000000000 Z
+date: 2013-03-28 00:00:00.000000000 Z
 dependencies: []
 description: Logging library that provides the ability to add class/module specific
   filters
@@ -66,15 +66,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3583664298557571275
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3583664298557571275
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Logging library that provides the ability to add class/module specific filters