loggr 1.0.0

data/lib/loggr/adapter/abstract.rb

@@ -0,0 +1,25 @@
+module Loggr
+  module Adapter
+    
+    # A basically abstract base class for logger backend
+    # implementations, provides a default implementation for MDC (hash & thread local based).
+    #
+    # Ensure to implement `#logger`.
+    # 
+    class AbstractAdapter
+      
+      # Implement which creates a new instance of a logger.
+      def logger(name, options = {})
+        raise "#{self.class.name}#logger is declared `abstract': implement #logger method"
+      end
+      
+      # Use a simple thread local hash as fake MDC, because it's
+      # not supported by the logger anyway - but it should be available
+      # for consistency and usage.
+      def mdc
+        mdc_key = "#{self.class.name}.mdc"
+        Thread.current[mdc_key] ||= Hash.new
+      end      
+    end
+  end
+end

data/lib/loggr/adapter/base.rb

@@ -0,0 +1,54 @@
+require 'loggr/adapter/abstract'
+require 'logger'
+
+module Loggr
+  module Adapter
+    
+    # Default backend which is backed Rubys Stdlib Logger.
+    #
+    class BaseAdapter < AbstractAdapter
+      
+      # 
+      #
+      def logger(name, options = {})
+        name = normalize_name(name)
+        @loggers ||= {}
+        @loggers[name] ||= build_new_logger(name, options)
+      end
+      
+      protected
+        # Constructs a new logger instance for the supplied options, is called
+        # by `#loggers` when no logger with this name already exists - instead of
+        # creating a new logger...
+        #
+        def build_new_logger(name, options = {})
+          ::Logger.new(options[:to] || "#{name.to_s.gsub(/[:\s\/]+/, '_')}.log").tap do |logger|
+            logger.level = options[:level] || Logger::INFO
+            logger.progname = name
+          end        
+        end
+        
+        # Because we should also allow using class names, or objects
+        # to construct new loggers (like in SLF4J), it makes sense to
+        # have a method which normalizes some input, be it a string or
+        # whatnot to convert to an appropriate name.
+        #
+        # Subclasses are of course allowed to override this, of course
+        # loggers themself are allowed to tweak that name further - this
+        # is basically to enable creating loggers from classes/objects
+        # for AS::BufferedLoggers and Stdlib Loggers.
+        #
+        def normalize_name(name)
+          return name.to_str if name.respond_to?(:to_str)
+          case name
+            when Symbol then name.to_s
+            when Module then name.name.to_s
+            else name.class.name.to_s
+          end
+        end        
+    end
+    
+    # Okay, basically a singleton thus create instance
+    Base = BaseAdapter.new
+  end
+end

data/lib/loggr/adapter/buffered.rb

@@ -0,0 +1,25 @@
+require 'loggr/adapter/base'
+require 'active_support/buffered_logger'
+
+module Loggr
+  module Adapter
+    
+    # Backend for `ActiveSupport::BufferedLogger`.
+    #
+    class BufferedAdapter < BaseAdapter
+      
+      protected
+        # Creates a new `AS::BufferedLogger` instance, note that BufferedLogger has
+        # no support for setting a default progname, so `name` is basically ignored.
+        #
+        def build_new_logger(name, options = {})
+          ActiveSupport::BufferedLogger.new(options[:to] || "#{name.to_s.gsub(/[\s\/]+/, '_')}.log").tap do |logger|
+            logger.level = options[:level] || ActiveSupport::BufferedLogger::INFO
+          end
+        end
+    end
+    
+    # THE instance
+    Buffered = BufferedAdapter.new
+  end
+end

data/lib/loggr/adapter/nop.rb

@@ -0,0 +1,39 @@
+require 'loggr/adapter/abstract'
+
+module Loggr
+  module Adapter
+
+    # Silences all logging operations, nothing is written at all.
+    #
+    class NOPAdapter < AbstractAdapter
+      
+      class NOPLogger
+        # Has no impact anyway :)
+        attr_accessor :level
+        
+        # Just to ensure compatiability with AS::BufferedLogger
+        attr_reader :auto_flushing, :flush, :close
+        
+        # Yields empty implementations for all severities
+        %w{trace debug info warn error fatal}.each do |severity|
+          class_eval <<-EOT, __FILE__, __LINE__ + 1
+            def #{severity}(*args, &block)   # def debug(*args, &block)
+            end                              # end
+
+            def #{severity}?                 # def debug?
+              false                          #   false
+            end                              # end
+          EOT
+        end
+      end
+      
+      # Get single NOPLogger instance
+      def logger(name, options = {})
+        @logger ||= NOPLogger.new
+      end      
+    end
+    
+    # THE instance
+    NOP = NOPAdapter.new
+  end
+end

data/lib/loggr/adapter/rails.rb

@@ -0,0 +1,36 @@
+require 'loggr/adapter/abstract'
+
+module Loggr
+  module Adapter
+    
+    # Always uses the logger defined on `Rails.logger`, CAVEAT ensure to never
+    # ever set `Rails.logger` to this backend, i.e.:
+    #
+    #    # IF YOU DID THIS...
+    #    Loggr.adapter = Loggr::Adapter::Rails
+    #
+    #    MyApp::Application.configure do
+    #      # ...NEVER DO THIS !!!
+    #      config.logger = Loggr.logger('rails')
+    #    end
+    #
+    # If you are using the rails adapter, ensure that you do not override `config.logger`
+    # with an instance of the Rails adapter logger factory. Keep the default logger, or
+    # create a new one using:
+    #
+    #    config.logger = Loggr.logger('rails', :backend => Loggr::Adapter::Buffered)
+    #
+    class RailsAdapter < AbstractAdapter
+      
+      # The rails backend ignores all options as it just returns
+      # always returns `Rails.logger` :)
+      #
+      def logger(name, options = {})
+        ::Rails.logger
+      end
+    end
+    
+    # THE Rails backed implementation instance
+    Rails = RailsAdapter.new
+  end
+end

data/lib/loggr/adapter/slf4j.rb

@@ -0,0 +1,30 @@
+require 'loggr/slf4j'
+require 'loggr/adapter/base'
+
+module Loggr
+  module Adapter
+    
+    # Provides an adapter for the SLF4J Logger.
+    #
+    class SLF4JAdapter < BaseAdapter      
+      # Use the SLF4J backed real MDC.
+      def mdc
+        @mdc ||= Loggr::SLF4J::MDC
+      end
+      
+      protected
+        # Create a new SLF4JLogger instance.
+        def build_new_logger(name, options = {})
+          Loggr::SLF4J::Logger.new(name, options)
+        end
+        
+        # Uses Logger#in_java_notation on name
+        def normalize_name(name)
+          Loggr::SLF4J::Logger.in_java_notation(name)
+        end
+    end
+    
+    # THE instance of it
+    SLF4J = SLF4JAdapter.new
+  end
+end

data/lib/loggr/factory.rb

@@ -0,0 +1,9 @@
+require 'loggr/adapter'
+
+# This is basically a factory facade to create new Logger instances
+# which behave all like standard Ruby Stdlib Loggers.
+#
+class LoggerFactory  
+  # Ensure we get all those factory methods directly here
+  extend Loggr::Adapter
+end

data/lib/loggr/lint.rb

@@ -0,0 +1,54 @@
+require 'tempfile'
+
+module Loggr
+  module Lint
+    
+    # == Adapter and Logger Lint Tests
+    #
+    # You can test whether an object provides a compliant adapter and logger
+    # by including <tt>Logger::Lint::Tests</tt>
+    # in your tests.
+    #
+    # Ensure you set the instance variable <tt>@adapter</tt> to your adapter.
+    #
+    module Tests
+      def test_adapter_logger
+        assert adapter.respond_to?(:logger), "The adapter should respond to #logger"
+        assert adapter.method('logger').arity == -2, "The adapter should accept two parameters for #logger, name and options hash"        
+      end
+      
+      def test_adapter_mdc
+        assert adapter.respond_to?(:mdc), "The adapter should respond to #mdc"
+        assert adapter.method('mdc').arity == 0, "The adapter should accept no parameters for #mdc"
+      end
+      
+      def test_mdc_methods
+        mdc = adapter.mdc
+        assert mdc.respond_to?(:[]=), "The mdc should respond to #[]="
+        assert mdc.respond_to?(:[]),  "The mdc should respond to #[]"
+        assert mdc.respond_to?(:delete),  "The mdc should respond to #delete"
+        assert mdc.respond_to?(:clear),   "The mdc should respond to #clear"
+        assert mdc.respond_to?(:to_hash), "The mdc should respond to #to_hash"
+      end
+      
+      def test_logger_methods
+        tempfile = Tempfile.new('lint')
+        logger = adapter.logger('lint', :to => tempfile.path)
+        %w{debug info warn error fatal}.each do |level|
+          assert logger.respond_to?(level), "The logger should respond to ##{level}"
+          assert logger.respond_to?("#{level}?"), "The logger should respond to ##{level}?"
+        end        
+      ensure
+        tempfile.unlink
+      end
+      
+      protected
+      
+        # Access the adapter, defined by <tt>@adapter</tt>.
+        def adapter
+          assert !!@adapter, "An adapter must be defined"
+          @adapter
+        end
+    end
+  end
+end

data/lib/loggr/severity.rb

@@ -0,0 +1,16 @@
+module Loggr
+  
+  # Exactly the same severities as Ruby Stdlib Logger.
+  #
+  module Severity
+    # Okay, trace is new :)
+    TRACE = -1
+    
+    DEBUG = 0
+    INFO  = 1
+    WARN  = 2
+    ERROR = 3
+    FATAL = 4
+    UNKNOWN = 5
+  end
+end

data/lib/loggr/slf4j.rb

@@ -0,0 +1,7 @@
+module Loggr
+  module SLF4J
+    
+    autoload :Logger,  'loggr/slf4j/logger'
+    autoload :MDC,     'loggr/slf4j/mdc'
+  end
+end

data/lib/loggr/slf4j/jars.rb

@@ -0,0 +1,44 @@
+module Loggr
+  module SLF4J
+    
+    # Simple access to both SLF4J and Logback implementations, for testing
+    # and/or warbler integration.
+    #
+    module Jars
+      
+      # Base dir, where the jar files reside, this is "lib/" ergo "lib/loggr/slf4j/jars.rb/../../../"
+      SLF4J_LIB_PATH = File.expand_path(File.dirname(File.dirname(File.dirname(__FILE__))))
+   
+    
+      # Path to SLF4J API
+      def slf4j_api_jar_path
+        @api_jar_path ||= Dir[File.join(SLF4J_LIB_PATH, 'slf4j-api-*.jar')].first
+      end
+      module_function :slf4j_api_jar_path
+  
+      # Logback Core JAR
+      def logback_core_jar_path
+        @logback_core_jar_path ||= Dir[File.join(SLF4J_LIB_PATH, 'logback-core-*.jar')].first
+      end
+      module_function :logback_core_jar_path
+  
+      # Logback Classic JAR
+      def logback_jar_path
+        @logback_jar_path ||= Dir[File.join(SLF4J_LIB_PATH, 'logback-classic-*.jar')].first
+      end
+      module_function :logback_jar_path
+      
+      # Require all JARs, if `all` is set to `false`, then only
+      # the SLF4J API jar is loaded.
+      def require_slf4j_jars!(all = true)
+        require self.slf4j_api_jar_path
+        if all
+          require self.logback_core_jar_path
+          require self.logback_jar_path
+        end
+      end
+      module_function :require_slf4j_jars!
+      
+    end
+  end
+end

data/lib/loggr/slf4j/logger.rb

@@ -0,0 +1,88 @@
+require 'loggr/severity'
+
+module Loggr
+  module SLF4J
+    
+    # Simple marker factory which uses `org.slf4j.MarkerFactory`, but
+    # caches the result in a local ruby hash, by name.
+    class MarkerFactory
+      
+      # Get marker for any non-empty string.
+      def self.[](name)
+        name = name.to_s.strip
+        return nil if name.length == 0
+        @markers ||= {}
+        @markers[name] ||= Java::OrgSlf4j::MarkerFactory.getMarker(name)
+      end
+    end
+    
+    # A logger which is backed by SLF4J, thus only useable in a JRuby environment.
+    #
+    class Logger
+      
+      # Get severities
+      include Loggr::Severity
+      
+      # Basically has *no* impact, because is handled by SLF4J
+      attr_accessor :level
+      
+      # Just to ensure compatiability with AS::BufferedLogger
+      attr_reader :auto_flushing, :flush, :close
+      
+      # Access raw SLF4J logger & marker instances
+      attr_reader :java_logger, :java_marker
+      
+      # Create a new Logger instance for the given name
+      #
+      def initialize(name, options = {})
+        name = self.class.in_java_notation(name)
+        @java_logger = Java::OrgSlf4j::LoggerFactory.getLogger(name.to_s)
+        @java_marker = MarkerFactory[options[:marker]]
+        
+        # seriously, this is handled by slf4j and pretty dynamic
+        @level = Logger::UNKNOWN
+        @auto_flushing = true
+      end
+      
+      # Create the logger methods via meta programming, sweet.
+      %w{trace debug info warn error}.each do |severity|
+        class_eval <<-EOT, __FILE__, __LINE__ + 1
+          def #{severity}(message = nil, progname = nil, &block)                         # def debug(message = nil, progname = nil, &block)
+            marker = (progname ? MarkerFactory[progname] : nil) || java_marker           #   marker = (progname ? MarkerFactory[progname] : nil) || java_marker
+            if java_logger.is_#{severity}_enabled(marker)                                #   if java_logger.is_debug_enabled(marker)
+              java_logger.#{severity}(marker, build_message(message, progname, &block))  #     java_logger.debug(marker, build_message(message, progname, &block))
+            end                                                                          #   end
+          end                                                                            # end
+          
+          def #{severity}?                                                               # def debug?
+            !!java_logger.is_#{severity}_enabled(java_marker)                            #   !!java_logger.is_debug_enabled(java_marker)
+          end                                                                            # end
+        EOT
+      end
+
+      # Add support for fatal, just alias to error
+      alias_method :fatal, :error
+      alias_method :fatal?, :error?
+      
+      # If a class, module or object is used converts `Foo::Bar::SomeThing` to
+      # java notation: `foo.bar.SomeThing`. Symbols and Strings are left as is!
+      #
+      def self.in_java_notation(name)
+        return name.to_s if name.respond_to?(:to_str) || name.is_a?(Symbol)
+        name = name.is_a?(Module) ? name.name.to_s : name.class.name.to_s
+        parts = name.split('::')
+        last  = parts.pop
+        parts.map { |p| p.downcase }.push(last).join('.')
+      end
+            
+      protected
+        
+        # Construct the message, note that progname will be ignored, maybe set as
+        # MDC?
+        def build_message(message = nil, progname = nil, &block)
+          message = yield if message.nil? && block_given?
+          message.to_s.gsub(/$\s*^/, '')
+        end        
+    end
+  end
+end