log4r-exceptionable 0.5.0 → 0.5.1

data/CHANGELOG

@@ -1,3 +1,8 @@
+0.5.1 (06/15/2012)
+------------------
+
+Added source logger detection and use <ccfba07>
+
 0.5.0
 -----
 

data/README.md

@@ -17,15 +17,28 @@ To use
 Add to some initializer code:
 
     Log4rExceptionable::Configuration.configure do |config|
-      # at least one logger needs to be set
+      
+      # The default loggers used when a source logger is not available
+      # required (at least one logger needs to be set, but you don't need
+      # to set rack if using resque, and vice versa)
+      #
       config.rack_failure_logger = "rails::SomeRackLogger"
       config.resque_failure_logger = "rails::SomeResqueLogger"
+
+      # Prevent the detection and use of the source class's logger
+      # The source logger is taken from the resque class raising
+      # the exception, rails controller raising the exception,
+      # or rack_env['rack.logger']
+      # optional (defaults to true)
+      #
+      # config.use_source_logger = false
+      
     end
   
     Rails.application.config.middleware.use "Log4rExceptionable::RackFailureHandler"
     Resque::Failure.backend = Log4rExceptionable::ResqueFailureHandler
 
-All failures will be logged using the given log4r logger name (or log4r logger instance if supplied instead)
+All failures will be logged using the source logger or the given logger if a source is not available. The logger can be set using their log4r fullname or a log4r logger instance.
 
 Author
 ------

data/lib/log4r-exceptionable/configuration.rb

@@ -1,26 +1,24 @@
 module Log4rExceptionable
     
-  # Failure backends that log exceptions with log4r
-  #
-  # Log4rExceptionable::Configuration.configure do |config|
-  #   # required
-  #   config.resque_failure_logger = "rails::SomeLogger"
-  #   config.rack_failure_logger = "rails::SomeLogger"
-  # end
-  #
-  # Rails.application.config.middleware.use "Log4rExceptionable::RackFailureHandler"
-  # Resque::Failure.backend = Log4rExceptionable::ResqueFailureHandler
+  # Configuration for the failure backends that log exceptions with log4r
   #
   class Configuration
 
     class << self
-      # required
+      # required - default loggers used if source logger not available
       attr_accessor :rack_failure_logger, :resque_failure_logger
+      attr_accessor :use_source_logger
     end
 
+    # default values
+    self.use_source_logger = true
+
     def self.configure
       yield self
-      raise "log4r-exceptionable requires a rack_failure_logger or resque_failure_logger" unless self.rack_failure_logger || self.resque_failure_logger
+
+      if ! self.rack_failure_logger && ! self.resque_failure_logger
+        raise "log4r-exceptionable requires a rack_failure_logger or resque_failure_logger"
+      end
 
       if self.rack_failure_logger
         self.set_logger(:rack_failure_logger)

data/lib/log4r-exceptionable/rack_failure_handler.rb

@@ -10,10 +10,6 @@ module Log4rExceptionable
       @app = app
     end
   
-    def logger
-      Log4rExceptionable::Configuration.rack_failure_logger
-    end
-    
     def call(env)
       # Make thread safe
       dup._call(env)
@@ -62,8 +58,17 @@ module Log4rExceptionable
             end
           end
           
+          controller = env['action_controller.instance']
+          if controller && controller.respond_to?(:logger) && controller.logger.instance_of?(Log4r::Logger)
+            error_logger = controller.logger 
+          elsif env['rack.logger'] && env['rack.logger'].instance_of?(Log4r::Logger)
+            error_logger = env['rack.logger']
+          else
+            error_logger = Log4rExceptionable::Configuration.rack_failure_logger
+          end
+          
           message = "#{exception.class}: #{exception.message}"
-          logger.error(message)
+          error_logger.error(message)
         ensure
           # Since this is somewhat of a global map, clean the keys
           # we put in so other log messages don't see them

data/lib/log4r-exceptionable/resque_failure_handler.rb

@@ -6,10 +6,6 @@ module Log4rExceptionable
   #
   class ResqueFailureHandler < ::Resque::Failure::Base
 
-    def logger
-      Log4rExceptionable::Configuration.resque_failure_logger
-    end
-        
     def save
       begin
         mdc = Log4r::MDC
@@ -29,9 +25,16 @@ module Log4rExceptionable
           mdc.put("resque_queue", queue.to_s)
           mdc.put("resque_class", payload['class'].to_s)
           mdc.put("resque_args", payload['args'].inspect.to_s)
+
+          payload_class = Resque.constantize(payload['class']) rescue nil
+          if payload_class && payload_class.respond_to?(:logger) && payload_class.logger.instance_of?(Log4r::Logger)
+            error_logger = payload_class.logger
+          else
+            error_logger = Log4rExceptionable::Configuration.resque_failure_logger
+          end
           
           message = "#{exception.class}: #{exception.message}"
-          logger.error(message)
+          error_logger.error(message)
         ensure
           # Since this is somewhat of a global map, clean the keys
           # we put in so other log messages don't see them

data/lib/log4r-exceptionable/version.rb

@@ -1,3 +1,3 @@
 module Log4rExceptionable
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/spec/rack_failure_handler_spec.rb

@@ -3,13 +3,46 @@ require "spec_helper"
 describe Log4rExceptionable::RackFailureHandler do
   include Rack::Test::Methods
 
+  class FakeController
+    class << self
+      attr_accessor :logger
+    end
+    def logger
+      self.class.logger
+    end
+  end
+  
   class TestApp
+    
     def call(env)
-      if env['PATH_INFO'] =~ /error/
-        raise "I failed"
-      else
-        return [200, {"Content-Type" => "text"}, ["hello"]]
+      error = env['PATH_INFO'] =~ /error/
+      
+      case env['PATH_INFO']
+        when /nil_controller_logger/
+          FakeController.logger = nil
+          env['action_controller.instance'] = FakeController.new
+          error = true
+        when /other_controller_logger/
+          FakeController.logger = Object.new
+          env['action_controller.instance'] = FakeController.new
+          error = true
+        when /controller_logger/
+          FakeController.logger = Log4r::Logger["ControllerLogger"] || Log4r::Logger.new("ControllerLogger")
+          env['action_controller.instance'] = FakeController.new
+          error = true
+        when /nil_rack_logger/
+          env['rack.logger'] = nil
+          error = true
+        when /other_rack_logger/
+          env['rack.logger'] = Object.new
+          error = true
+        when /rack_logger/
+          env['rack.logger'] = Log4r::Logger["RackLogger"] || Log4r::Logger.new("RackLogger")
+          error = true
       end
+      
+      raise "I failed" if error
+      return [200, {"Content-Type" => "text"}, ["hello"]]
     end
   end
   
@@ -45,6 +78,74 @@ describe Log4rExceptionable::RackFailureHandler do
       }.should raise_error("I failed")
     end
     
+    it "uses default logger if controller logger is nil" do
+      
+      Log4r::Logger['racklogger'].should_receive(:error) do |msg|
+        msg.should == "RuntimeError: I failed"
+      end
+      
+      lambda {
+        get "/nil_controller_logger"
+      }.should raise_error("I failed")
+    end
+    
+    it "uses default logger if controller logger is not log4r" do
+      
+      Log4r::Logger['racklogger'].should_receive(:error) do |msg|
+        msg.should == "RuntimeError: I failed"
+      end
+      
+      lambda {
+        get "/other_controller_logger"
+      }.should raise_error("I failed")
+    end
+    
+    it "uses controller logger if set" do
+      Log4r::Logger.new('ControllerLogger')
+      Log4r::Logger['racklogger'].should_not_receive(:error)
+      Log4r::Logger['ControllerLogger'].should_receive(:error) do |msg|
+        msg.should == "RuntimeError: I failed"
+      end
+      
+      lambda {
+        get "/controller_logger"
+      }.should raise_error("I failed")
+    end
+    
+    it "uses default logger if rack logger is nil" do
+      
+      Log4r::Logger['racklogger'].should_receive(:error) do |msg|
+        msg.should == "RuntimeError: I failed"
+      end
+      
+      lambda {
+        get "/nil_rack_logger"
+      }.should raise_error("I failed")
+    end
+    
+    it "uses default logger if rack logger is not log4r" do
+      
+      Log4r::Logger['racklogger'].should_receive(:error) do |msg|
+        msg.should == "RuntimeError: I failed"
+      end
+      
+      lambda {
+        get "/other_rack_logger"
+      }.should raise_error("I failed")
+    end
+    
+    it "uses rack logger if set" do
+      Log4r::Logger.new('RackLogger')
+      Log4r::Logger['racklogger'].should_not_receive(:error)
+      Log4r::Logger['RackLogger'].should_receive(:error) do |msg|
+        msg.should == "RuntimeError: I failed"
+      end
+      
+      lambda {
+        get "/rack_logger"
+      }.should raise_error("I failed")
+    end
+    
   end
   
 end

data/spec/resque_failure_handler_spec.rb

@@ -11,6 +11,36 @@ describe Log4rExceptionable::ResqueFailureHandler do
       end
     end
 
+    class SomeJobWithNilLogger
+      def self.logger
+        nil
+      end
+      
+      def self.perform(*args)
+        raise "I failed"
+      end
+    end
+
+    class SomeJobWithOtherLogger
+      def self.logger
+        self
+      end
+      
+      def self.perform(*args)
+        raise "I failed"
+      end
+    end
+    
+    class SomeJobWithLogger
+      def self.logger
+        Log4r::Logger["SomeJobWithLogger"] || Log4r::Logger.new("SomeJobWithLogger")
+      end
+      
+      def self.perform(*args)
+        raise "I failed"
+      end
+    end
+
     before(:all) do
       Log4rExceptionable::Configuration.configure do |config|
         config.resque_failure_logger = 'resquelogger'
@@ -36,6 +66,37 @@ describe Log4rExceptionable::ResqueFailureHandler do
       run_resque_job(SomeJob, 'foo', :queue => :somequeue, :inline => true)
     end
     
+    it "uses default logger if job logger is nil" do
+      
+      Log4r::Logger['resquelogger'].should_receive(:error) do |msg|
+        msg.should == "RuntimeError: I failed"
+        Log4r::MDC.get('resque_class').should == "SomeJobWithNilLogger"
+      end
+      
+      run_resque_job(SomeJobWithNilLogger, 'foo', :queue => :somequeue, :inline => true)
+    end
+    
+    it "uses default logger if job logger is not log4r" do
+      
+      Log4r::Logger['resquelogger'].should_receive(:error) do |msg|
+        msg.should == "RuntimeError: I failed"
+        Log4r::MDC.get('resque_class').should == "SomeJobWithOtherLogger"
+      end
+      
+      run_resque_job(SomeJobWithOtherLogger, 'foo', :queue => :somequeue, :inline => true)
+    end
+    
+    it "uses job logger if set" do
+      Log4r::Logger.new('SomeJobWithLogger')
+      Log4r::Logger['resquelogger'].should_not_receive(:error)
+      Log4r::Logger['SomeJobWithLogger'].should_receive(:error) do |msg|
+        msg.should == "RuntimeError: I failed"
+        Log4r::MDC.get('resque_class').should == "SomeJobWithLogger"
+      end
+      
+      run_resque_job(SomeJobWithLogger, 'foo', :queue => :somequeue, :inline => true)
+    end
+    
   end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: log4r-exceptionable
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-14 00:00:00.000000000 Z
+date: 2012-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake