loggr 1.0.0 → 1.1.0

data/lib/loggr/adapter/buffered.rb

@@ -1,24 +1,26 @@
 require 'loggr/adapter/base'
+require 'loggr/support/annotations'
 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 = ActiveSupport::BufferedLogger.new(options[:to] || "#{name.to_s.gsub(/[\s\/]+/, '_')}.log").tap do |logger|
             logger.level = options[:level] || ActiveSupport::BufferedLogger::INFO
           end
+          Loggr::Support::Annotations.enhance(logger)
         end
     end
-    
+
     # THE instance
     Buffered = BufferedAdapter.new
   end

data/lib/loggr/adapter/nop.rb

@@ -1,4 +1,5 @@
 require 'loggr/adapter/abstract'
+require 'loggr/support/annotations'
 
 module Loggr
   module Adapter
@@ -6,14 +7,17 @@ module Loggr
     # 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
-        
+
+        # Support fuer Annotations wie `tagged` und `mapped`.
+        include Loggr::Support::Annotations::NOPSupport
+
         # Yields empty implementations for all severities
         %w{trace debug info warn error fatal}.each do |severity|
           class_eval <<-EOT, __FILE__, __LINE__ + 1
@@ -26,13 +30,13 @@ module Loggr
           EOT
         end
       end
-      
+
       # Get single NOPLogger instance
       def logger(name, options = {})
         @logger ||= NOPLogger.new
-      end      
+      end
     end
-    
+
     # THE instance
     NOP = NOPAdapter.new
   end

data/lib/loggr/lint.rb

@@ -2,27 +2,51 @@ 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.
+    # Ensure you set the instance variable <tt>@adapter</tt> to the adapter to lint.
     #
     module Tests
+
+      # Verifies `adapter#logger`, it checks that:
+      #
+      # - the factory method named #logger exists
+      # - that it accepts two arguments, name and options hash
+      # - the returned instnace responds to debug, info, warn, error and fatal
+      # - responds to tagged and mapped
+      #
       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"        
+        assert adapter.method('logger').arity == -2, "The adapter should accept two parameters for #logger, name and options hash"
+
+        @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
+
+        assert logger.respond_to?(:tagged), "The logger should respond to #tagged"
+        assert logger.respond_to?(:mapped), "The logger should respond to #mapped"
+      ensure
+        @tempfile.unlink if @tempfile
       end
-      
+
+      # Verifies `adapter#mdc`, it checks that:
+      #
+      # - the factory method named #mdc exists
+      # - it accepts no arguments
+      # - the returned mdc responds to []=, [], delete, clear and to_hash
+      #
       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 #[]"
@@ -30,21 +54,11 @@ module Loggr
         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>.
+
+        # Access the adapter, must be defined <tt>@adapter</tt> in the
+        # `setup` method.
         def adapter
           assert !!@adapter, "An adapter must be defined"
           @adapter

data/lib/loggr/slf4j/logger.rb

@@ -1,12 +1,13 @@
 require 'loggr/severity'
+require 'loggr/slf4j/mdc'
 
 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
@@ -15,35 +16,36 @@ module Loggr
         @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
-      
+      attr_reader :java_logger, :java_marker, :java_mdc
+
       # 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]]
-        
+        @java_mdc = options[:mdc] || Loggr::SLF4J::MDC
+
         # 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
@@ -53,7 +55,7 @@ module Loggr
               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
@@ -63,7 +65,28 @@ module Loggr
       # Add support for fatal, just alias to error
       alias_method :fatal, :error
       alias_method :fatal?, :error?
-      
+
+      # Uses the mapped diagnostic context to add tags, like
+      # ActiveSupport 3.2's TaggedLogger.
+      #
+      def tagged(*new_tags)
+        old_tags = java_mdc[:tags].to_s
+        java_mdc[:tags] = (old_tags.split(', ') + new_tags.flatten).join(', ')
+        yield
+      ensure
+        java_mdc[:tags] = old_tags.length == 0 ? nil : old_tags
+      end
+
+      # A more describtive alternative to tagged is mapped, which just makes
+      # use of the MDC directly, basically.
+      def mapped(hash = {})
+        old_keys = hash.keys.inject({}) { |hsh,k| hsh[k] = java_mdc[k]; hsh }
+        hash.each { |key, value| java_mdc[key] = value }
+        yield
+      ensure
+        old_keys.each { |key, value| java_mdc[key] = value }
+      end
+
       # 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!
       #
@@ -74,15 +97,15 @@ module Loggr
         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
 end

data/lib/loggr/slf4j/mdc.rb

@@ -1,13 +1,13 @@
 module Loggr
   module SLF4J
-    
+
     # Wrapper around the SLF4J MDC.
     #
     class MDCWrapper
-      
+
       # Access the original SLF4J MDC
       attr_accessor :java_mdc
-      
+
       # Create a new SLF4J MDC with the supplied implementation.
       def initialize(impl = Java::OrgSlf4j::MDC)
         @java_mdc = impl
@@ -15,20 +15,20 @@ module Loggr
 
       # Read a key from the MDC.
       def [](key); java_mdc.get(key.to_s) end
-      
+
       # Write a value to the MDC.
-      def []=(key, value); java_mdc.put(key.to_s, value.to_s) end
-      
+      def []=(key, value); value.nil? ? java_mdc.remove(key.to_s) : java_mdc.put(key.to_s, value.to_s) end
+
       # Remove a key from the MDC.
       def delete(key); java_mdc.remove(key.to_s) end
-      
+
       # Clear all keys from the MDC.
       def clear; java_mdc.clear() end
-      
+
       # Convert MDC to a real hash.
       def to_hash; java_mdc.getCopyOfContextMap().freeze end
     end
-    
+
     # An instance is available as MDC :)
     MDC = MDCWrapper.new
   end

data/lib/loggr/support/annotations.rb

@@ -0,0 +1,40 @@
+module Loggr
+
+  module Support
+
+    #
+    #
+    module Annotations
+
+      # A doing nothing implementation of tagged & mapped,
+      # just to ensure the methods exist.
+      module NOPSupport
+        def tagged(*args); yield if block_given? end
+        alias_method :mapped, :tagged
+      end
+
+      # Enhances supplied logger with the required features
+      # to handle both `tagged` and `mapped` on the logger itself.
+      #
+      def self.enhance(logger)
+        return ::ActiveSupport::TaggedLogging.new(logger) if defined?(::ActiveSupport::TaggedLogging)
+        logger.send(:extend, NOPSupport)
+      end
+    end
+  end
+end
+
+# Try to load AS::TaggedLogging
+begin
+  require 'active_support/tagged_logging'
+
+  # Enable support for `mapped(:user => "demo")` which falls
+  # back to make use of its `tagged` method.
+  class ::ActiveSupport::TaggedLogging
+
+    # Uses `tagged` to tag items with the hash of infos.
+    def mapped(hash = {}, &block)
+      tagged(hash.map { |h,k| "#{h}=#{k}" }, &block)
+    end
+  end
+rescue LoadError; end # uhm, ignore we have other ideas ;)

data/lib/loggr/version.rb

@@ -1,3 +1,4 @@
 module Loggr
-  VERSION = "1.0.0"
+  # Called gem version for compatibility with loggr/agents/loggr-rb (loggr-rb gem)
+  GEM_VERSION = "1.1.0"
 end

data/loggr.gemspec

@@ -4,7 +4,7 @@ require "loggr/version"
 
 Gem::Specification.new do |s|
   s.name        = "loggr"
-  s.version     = Loggr::VERSION
+  s.version     = Loggr::GEM_VERSION
   s.platform    = Gem::Platform::RUBY
   s.summary     = 'Logger factory framework (including an SLF4J wrapper)'
   s.description = 'Adapters for different ruby logging backends. Create loggers using different adapters, like Logger (Stdlib), Rails or SLF4J (in JRuby only).'
@@ -20,7 +20,9 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_path  = 'lib'
-  
+
+  s.add_development_dependency "rake", ">= 0.8.7"
   s.add_development_dependency "minitest", ">= 2.3.0"
   s.add_development_dependency "activesupport", ">= 3.0.0"
+  s.add_development_dependency "appraisal", ">= 0.3.8"
 end

data/test/test_helper.rb

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'minitest/autorun'
 require 'tempfile'
+require 'active_support/version'
 
 # Just to provide some shim ;)
 module Loggr
@@ -11,26 +12,31 @@ module Loggr
 end
 
 class MiniTest::Unit::TestCase
-  
+
   # Path to root
   ROOT = File.dirname(File.dirname(__FILE__))
-      
-  # Returns `true` if running in java/jruby  
+
+  # Returns `true` if running in java/jruby
   def self.jruby?; !!(RUBY_PLATFORM =~ /java/) end
-    
+
   # Same at instance level
   def jruby?; self.class.jruby? end
-  
+
   # Yield block if java
   def if_jruby(&block)
     yield if block_given? && jruby?
-  end  
-    
+  end
+
   # Skip tests, unless using jruby
   def skip_unless_jruby
     skip("requires JRuby") unless jruby?
   end
-  
+
+  # Returns `true` if >= ActiveSupport 3.2 is used
+  def as_3_2?
+    ActiveSupport::VERSION::MAJOR >= 3 && ActiveSupport::VERSION::MINOR >= 2
+  end
+
   # Yields path to tempfile into block, ensures is cleaned up
   # afterwards
   def with_tempfile(name = 'file', &block)
@@ -40,11 +46,11 @@ class MiniTest::Unit::TestCase
   ensure
     tempfile.unlink
   end
-  
+
   # Ensure all log files are unlinked after block
   def unlink_log_files(&block)
     yield if block_given?
   ensure
     Dir[File.join(File.dirname(File.dirname(__FILE__))), '*.log'].each { |f| File.unlink(f) if f =~ /\.log$/ }
-  end  
+  end
 end