loggr 1.0.0

data/lib/loggr/slf4j/mdc.rb

@@ -0,0 +1,35 @@
+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
+      end
+
+      # 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
+      
+      # 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
+end

data/lib/loggr/version.rb

@@ -0,0 +1,3 @@
+module Loggr
+  VERSION = "1.0.0"
+end

data/loggr.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "loggr/version"
+
+Gem::Specification.new do |s|
+  s.name        = "loggr"
+  s.version     = Loggr::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).'
+
+  s.required_ruby_version     = ">= 1.8.7"
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.authors     = ["Lukas Westermann"]
+  s.email       = ["lukas@at-point.ch"]
+  s.homepage    = "https://github.com/at-point/loggr/wiki"
+
+  s.files         = `git ls-files`.split("\n")
+  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 "minitest", ">= 2.3.0"
+  s.add_development_dependency "activesupport", ">= 3.0.0"
+end

data/test/logback_helper.rb

@@ -0,0 +1,54 @@
+if RUBY_PLATFORM =~ /java/
+  require 'java'
+  require 'loggr/slf4j/jars'  
+  Loggr::SLF4J::Jars.require_slf4j_jars!
+  
+  class ArrayAppender
+    include Java::ChQosLogbackCore::Appender
+    
+    attr_reader   :events
+    attr_accessor :name
+    
+    def initialize(name = 'ArrayAppender')
+      @mutex = Mutex.new      
+      @name = name
+      @events = []
+    end
+    
+    alias_method :setName, :name=
+    alias_method :getName, :name
+    
+    def doAppend(event)
+      @mutex.synchronize { @events.push(event) }
+    end
+    
+    def stop
+    end
+    
+    def last
+      @events.last
+    end
+  end
+end
+
+class MiniTest::Unit::TestCase
+  # Configures logback for testing et al.
+  def setup_logback!
+    if RUBY_PLATFORM =~ /java/
+      @appender = ArrayAppender.new
+      
+      Java::OrgSlf4j::MDC.clear()
+      logger_context = Java::OrgSlf4j::LoggerFactory.getILoggerFactory()
+      root_logger = logger_context.getLogger(Java::OrgSlf4j::Logger::ROOT_LOGGER_NAME)
+      root_logger.detachAndStopAllAppenders()
+      root_logger.addAppender(@appender)
+      root_logger.setLevel(Java::ChQosLogbackClassic::Level::ALL)
+    end
+  end
+  
+  # Verifies log event based on level & message
+  def assert_log_event(exp_level, exp_message, event)
+    assert_equal exp_level, event.getLevel().toInt()
+    assert_equal exp_message, event.getFormattedMessage()
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'minitest/autorun'
+require 'tempfile'
+
+# Just to provide some shim ;)
+module Loggr
+  module SLF4J
+  end
+  module Adapter
+  end
+end
+
+class MiniTest::Unit::TestCase
+  
+  # Path to root
+  ROOT = File.dirname(File.dirname(__FILE__))
+      
+  # 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  
+    
+  # Skip tests, unless using jruby
+  def skip_unless_jruby
+    skip("requires JRuby") unless jruby?
+  end
+  
+  # Yields path to tempfile into block, ensures is cleaned up
+  # afterwards
+  def with_tempfile(name = 'file', &block)
+    tempfile = Tempfile.new(name)
+    yield(tempfile.path) if block_given?
+    tempfile.close
+  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

data/test/unit/adapter/abstract_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+require 'loggr/adapter/abstract'
+
+class Loggr::Adapter::AbstractTest < MiniTest::Unit::TestCase
+  def setup
+    @adapter = Loggr::Adapter::AbstractAdapter.new
+  end
+  
+  def test_logger_must_be_implemented_and_thus_throws_exception
+    assert_raises(RuntimeError) { @adapter.logger("logger") }
+  end
+end

data/test/unit/adapter/base_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+require 'loggr/lint'
+require 'loggr/adapter/base'
+
+module ATestModule
+  class ATestClass
+  end
+end
+
+class Loggr::Adapter::BaseTest < MiniTest::Unit::TestCase
+  def setup
+    @adapter = Loggr::Adapter::BaseAdapter.new
+  end
+  
+  def teardown
+    unlink_log_files
+  end
+  
+  include Loggr::Lint::Tests
+  
+  def test_base_should_be_a_base_adapter
+    assert Loggr::Adapter::Base.is_a?(Loggr::Adapter::BaseAdapter)
+  end
+  
+  def test_logger_instance_should_be_a_stdlib_logger_with_level_info
+    @logger = @adapter.logger 'test'
+    assert_kind_of ::Logger, @logger
+    assert_same ::Logger::INFO, @logger.level
+    assert_equal 'test', @logger.progname
+  end
+  
+  def test_logger_should_use_name_as_path
+    @logger = @adapter.logger 'test'
+    assert File.exist?(File.join(ROOT, 'test.log')), "./test.log should exist"
+    
+    @logger = @adapter.logger 'test name'
+    assert File.exist?(File.join(ROOT, 'test_name.log')), "./test_name.log should exist"
+  end
+  
+  def test_logger_should_use_class_name_as_name
+    @logger = @adapter.logger self
+    assert File.exist?(File.join(ROOT, 'Loggr_Adapter_BaseTest.log')), "./Loggr_Adapter_BaseTest.log should exist"
+  end
+  
+  def test_should_allow_to_option_to_provide_path
+    @logger = @adapter.logger 'test', :to => "other.log"
+    assert File.exist?(File.join(ROOT, 'other.log')), "./other.log should exist"    
+  end
+  
+  def test_should_setting_level_via_options
+    @logger = @adapter.logger 'test', :level => ::Logger::ERROR
+    assert_same ::Logger::ERROR, @logger.level
+  end
+  
+  def test_normalize_name_converts_all_inputs_to_sane_strings
+    assert_equal "logger", @adapter.send(:normalize_name, "logger")
+    assert_equal "logger", @adapter.send(:normalize_name, :logger)
+    assert_equal "Loggr::Logger", @adapter.send(:normalize_name, "Loggr::Logger")
+    assert_equal "Loggr::Adapter", @adapter.send(:normalize_name, Loggr::Adapter)
+    assert_equal "Loggr::Adapter::BaseTest", @adapter.send(:normalize_name, self)
+    assert_equal "ATestModule", @adapter.send(:normalize_name, ATestModule)
+    assert_equal "ATestModule::ATestClass", @adapter.send(:normalize_name, ATestModule::ATestClass)
+    assert_equal "ATestModule::ATestClass", @adapter.send(:normalize_name, ATestModule::ATestClass.new)    
+  end  
+end

data/test/unit/adapter/buffered_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+require 'loggr/lint'
+require 'loggr/adapter/buffered'
+
+class Loggr::Adapter::BufferedTest < MiniTest::Unit::TestCase
+    
+  def setup
+    @adapter = Loggr::Adapter::BufferedAdapter.new
+  end
+  
+  def teardown
+    unlink_log_files
+  end
+  
+  include Loggr::Lint::Tests
+  
+  def test_buffered_should_be_a_buffered_adapter
+    assert_kind_of Loggr::Adapter::BufferedAdapter, Loggr::Adapter::Buffered
+  end
+  
+  def test_logger_instance_should_be_a_buffered_logger_with_level_debug
+    @logger = @adapter.logger 'test'
+    assert_kind_of ActiveSupport::BufferedLogger, @logger
+    assert_same ActiveSupport::BufferedLogger::INFO, @logger.level
+  end
+  
+  def test_logger_should_use_name_as_path
+    @logger = @adapter.logger 'test'
+    assert File.exist?(File.join(ROOT, 'test.log')), "./test.log should not exist"
+    
+    @logger = @adapter.logger 'test name'
+    assert File.exist?(File.join(ROOT, 'test_name.log')), "./test_name.log should not exist"
+  end
+  
+  def test_should_allow_to_option_to_provide_path
+    @logger = @adapter.logger 'test', :to => "other.log"
+    assert File.exist?(File.join(ROOT, 'other.log')), "./other.log should not exist"    
+  end
+  
+  def test_should_setting_level_via_options
+    @logger = @adapter.logger 'test', :level => ActiveSupport::BufferedLogger::ERROR
+    assert_same ActiveSupport::BufferedLogger::ERROR, @logger.level
+  end
+end

data/test/unit/adapter/nop_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+require 'loggr/lint'
+require 'loggr/adapter/nop'
+
+class Loggr::Adapter::NOPTest < MiniTest::Unit::TestCase
+  def setup
+    @adapter = Loggr::Adapter::NOPAdapter.new
+  end
+  
+  include Loggr::Lint::Tests
+  
+  def test_nop_should_be_a_nop_adapter
+    assert_kind_of Loggr::Adapter::NOPAdapter, Loggr::Adapter::NOP
+  end
+  
+  def test_nop_should_not_write_any_files
+    with_tempfile do |file|
+      logger = @adapter.logger('nop', :to => file)
+      logger.error "oops, i failed?"
+      logger.close
+      assert File.read(file).length == 0, "Nop logger should not log anything at all, wtf!"
+    end
+  end
+end

data/test/unit/adapter/rails_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+require 'logger'
+require 'loggr/lint'
+require 'loggr/adapter'
+require 'loggr/adapter/rails'
+
+# mock Rails
+module MockRails
+  def self.logger
+    @logger ||= ::Logger.new('/dev/null')
+  end
+end
+
+class Loggr::Adapter::RailsTest < MiniTest::Unit::TestCase
+  def setup
+    Object.send(:remove_const, :Rails) if Object.const_defined?(:Rails)
+    Object.const_set(:Rails, ::MockRails)
+    @adapter = Loggr::Adapter::RailsAdapter.new
+  end
+  
+  include Loggr::Lint::Tests
+  
+  def test_rails_should_be_a_rails_adapter
+    assert_kind_of Loggr::Adapter::RailsAdapter, Loggr::Adapter::Rails
+  end
+  
+  def test_should_use_same_logger_as_rails
+    assert_equal ::Rails.logger, Loggr::Adapter::Rails.logger('log')
+  end
+  
+  def test_should_default_to_rails_adapter
+    clazz = Class.new do
+      extend Loggr::Adapter
+    end
+    
+    assert_equal Loggr::Adapter::Rails, clazz.adapter
+  end
+end

data/test/unit/adapter/slf4j_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+require 'loggr/lint'
+require 'loggr/adapter'
+
+class Loggr::Adapter::SLF4JTest < MiniTest::Unit::TestCase
+  def setup
+    setup_logback!    
+    if_jruby do
+      require 'loggr/adapter/slf4j'
+      @adapter = Loggr::Adapter::SLF4JAdapter.new
+    end
+  end
+
+  def test_lint
+    skip_unless_jruby
+    pass "include Loggr::Lint::Tests"
+  end
+    
+  include(Loggr::Lint::Tests) if jruby?
+
+  def test_slf4j_should_be_a_slf4j_adapter
+    skip_unless_jruby
+    assert Loggr::Adapter::SLF4J.is_a?(Loggr::Adapter::SLF4JAdapter)
+  end
+end

data/test/unit/factory_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+require 'loggr/lint'
+require 'loggr/adapter'
+require 'loggr/adapter/base'
+require 'loggr/factory'
+
+class MockInstanceFactory
+  include Loggr::Adapter
+end
+
+module Mocks
+  class MyAdapter < Loggr::Adapter::BaseAdapter; end
+end
+
+class Loggr::FactoryTest < MiniTest::Unit::TestCase
+  def setup
+    Object.send(:remove_const, :Rails) if Object.const_defined?(:Rails)
+    @factory = MockInstanceFactory.new
+    @adapter = LoggerFactory # lint it!
+    @adapter.adapter = Loggr::Adapter::Base
+  end
+    
+  def teardown
+    unlink_log_files
+  end  
+
+  def test_default_adapter_is_base
+    assert_equal @factory.adapter, Loggr::Adapter::Base
+  end
+  
+  def test_change_adapter_using_symbol
+    @factory.adapter = :buffered
+    assert_equal @factory.adapter, Loggr::Adapter::Buffered
+  end
+  
+  def test_change_adapter_to_slf4j_using_symbol
+    skip_unless_jruby    
+    @factory.adapter = :slf4j
+    assert_equal @factory.adapter, Loggr::Adapter::SLF4J    
+  end
+  
+  def test_change_adapter_using_string
+    @factory.adapter = 'NOP'
+    assert_equal @factory.adapter, Loggr::Adapter::NOP    
+  end
+  
+  def test_change_adapter_to_instance
+    @factory.adapter = Mocks::MyAdapter.new
+    assert_kind_of Mocks::MyAdapter, @factory.adapter
+  end
+  
+  # Lint LoggerFactory, should work the same as an adapter
+  include Loggr::Lint::Tests
+  
+  # Ensure class
+  def test_logger_factory
+    singleton_class = (class << LoggerFactory; self end)
+    assert singleton_class.included_modules.include?(Loggr::Adapter), "LoggerFactory should extend Loggr::Adapter"
+  end
+end