log4r-exceptionable 0.5.4 → 0.6.0

data/CHANGELOG

@@ -1,3 +1,8 @@
+0.6.0 (06/18/2012)
+------------------
+
+Add white/black lists for context keys Fix disabling source_logger <cb85b26>
+
 0.5.4 (06/15/2012)
 ------------------
 

data/README.md

@@ -29,13 +29,25 @@ Add to some initializer code:
       # 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)
+      # optional - defaults to true
       #
       # config.use_source_logger = false
       
+      # A whitelist of the context keys to include when logging.
+      # If this is set, _only_these keys will show up.
+      # optional - defaults to nil, so all keys get included
+      #
+      # config.context_inclusions = ['rack_env.rack.version']
+
+      # A blacklist of the context keys to exclude when logging.
+      # If this is set, the keys in here will not show up.
+      # optional - defaults to nil, so no keys get excluded
+      #
+      # config.context_exclusions = ['resque_args']
+      
     end
   
-    Rails.application.config.middleware.use "Log4rExceptionable::RackFailureHandler"
+    Rails.application.config.middleware.use Log4rExceptionable::RackFailureHandler
     Resque::Failure.backend = Log4rExceptionable::ResqueFailureHandler
 
 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.

data/lib/log4r-exceptionable.rb

@@ -1,6 +1,7 @@
 require "log4r"
 require "log4r-exceptionable/version"
 require "log4r-exceptionable/configuration"
+require "log4r-exceptionable/helper"
 
 # optional if only using resque
 begin

data/lib/log4r-exceptionable/configuration.rb

@@ -7,7 +7,12 @@ module Log4rExceptionable
     class << self
       # required - default loggers used if source logger not available
       attr_accessor :rack_failure_logger, :resque_failure_logger
+      # Allows one to force use of default loggers by setting to false
       attr_accessor :use_source_logger
+      # whitelist of context keys (e.g. keys in rack env) to include in log4r context when logging
+      attr_accessor :context_inclusions
+      # blacklist of context keys (e.g. keys in rack env) to exclude in log4r context when logging
+      attr_accessor :context_exclusions
     end
 
     # default values
@@ -27,6 +32,10 @@ module Log4rExceptionable
       if self.resque_failure_logger
         self.set_logger(:resque_failure_logger)
       end
+      
+      self.context_inclusions = Set.new(self.context_inclusions) if self.context_inclusions
+      self.context_exclusions = Set.new(self.context_exclusions) if self.context_exclusions
+      
     end
 
     def self.set_logger(accessor)
@@ -35,7 +44,7 @@ module Log4rExceptionable
         self.send("#{accessor}=", Log4r::Logger[name] || Log4r::Logger.new(name))
       end
     end
-
+    
   end
   
 end

data/lib/log4r-exceptionable/helper.rb

@@ -0,0 +1,44 @@
+module Log4rExceptionable
+    
+  # Configuration for the failure backends that log exceptions with log4r
+  #
+  module Helper
+    
+    def log_with_context
+      begin
+        mdc = Log4r::MDC
+        original_mdc = mdc.get_context
+        
+        begin
+          yield mdc
+        ensure
+          # Since this is somewhat of a global map, clean the keys
+          # we put in so other log messages don't see them
+          mdc.get_context.keys.each do |k|
+            mdc.remove(k) unless original_mdc.has_key?(k)
+          end
+        end
+        
+      rescue => e
+        $stderr.puts "Log4r Exceptionable could not log exception: " + e.message
+      end
+    end
+
+    def add_context(context, key, value)
+      inclusions = Log4rExceptionable::Configuration.context_inclusions
+      exclusions = Log4rExceptionable::Configuration.context_exclusions
+      
+      return if inclusions && ! inclusions.include?(key)
+      
+      if exclusions
+        if ! exclusions.include?(key)
+          context.put(key, value)
+        end
+      else
+        context.put(key, value)
+      end
+    end
+    
+  end
+  
+end

data/lib/log4r-exceptionable/rack_failure_handler.rb

@@ -4,6 +4,9 @@ module Log4rExceptionable
   # A rack middleware handler that logs exceptions with log4r
   #
   class RackFailureHandler
+    
+    include Log4rExceptionable::Helper
+    
     attr_reader :args
   
     def initialize(app, opts = {})
@@ -35,51 +38,45 @@ module Log4rExceptionable
     end
   
     def send_to_log4r(exception, env=nil)
-      begin
-        mdc = Log4r::MDC
-        original_mdc = mdc.get_context
+      
+      log_with_context do |context|
         
-        begin
-
-          if env and env.size > 0
-            env.each do |k, v|
-              begin
-                mdc.put("rack_env_#{k}", v)
-              rescue
-                puts "Log4r Exceptionable could not extract a rack env item: " + e.message
-              end
+        # add rack env to context so our logger can report with that data 
+        if env and env.size > 0
+          env.each do |k, v|
+            begin
+              add_context(context, "rack_env_#{k}", v)
+            rescue => e
+              $stderr.puts "Log4r Exceptionable could not extract a rack env item: " + e.message
             end
           end
-          
+        end
+
+        # Determine exception source class if possible, and use its logger if configured to do so.
+        error_logger = nil
+        if Log4rExceptionable::Configuration.use_source_logger
           controller = env['action_controller.instance']
           if controller && controller.respond_to?(:logger) && controller.logger.instance_of?(Log4r::Logger)
             error_logger = controller.logger 
             begin
-              mdc.put("rack_controller_name", controller.controller_name)
-              mdc.put("rack_action_name", controller.action_name)
+              add_context(context, "rack_controller_name", controller.controller_name)
+              add_context(context, "rack_action_name", controller.action_name)
             rescue => e
-              puts "Log4r Exceptionable could not extract controller names: " + e.message
+              $stderr.puts "Log4r Exceptionable could not extract controller names: " + e.message
             end
           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
-          
-          error_logger.error(exception)
-        ensure
-          # Since this is somewhat of a global map, clean the keys
-          # we put in so other log messages don't see them
-          mdc.get_context.keys.each do |k|
-            mdc.remove(k) unless original_mdc.has_key?(k)
           end
         end
         
-      rescue Exception => e
-        puts "Log4r Exceptionable could not log rack exception: " + e.message
+        error_logger ||= Log4rExceptionable::Configuration.rack_failure_logger
+        
+        error_logger.error(exception)
+        
       end
+      
     end
-  
+    
   end
 
 end

data/lib/log4r-exceptionable/resque_failure_handler.rb

@@ -5,47 +5,40 @@ module Log4rExceptionable
   # A Resque Failure backend that logs exceptions with log4r
   #
   class ResqueFailureHandler < ::Resque::Failure::Base
-
+    include Log4rExceptionable::Helper
+    
     def save
-      begin
-        mdc = Log4r::MDC
-        original_mdc = mdc.get_context
+      
+      log_with_context do |context|
         
-        begin
-          
-          data = payload.clone
-          payload_class_name = data.delete('class')
-          payload_class = Resque.constantize(payload_class_name) rescue payload_class_name
-          mdc.put("resque_worker", worker)
-          mdc.put("resque_queue", queue)
-          mdc.put("resque_class", payload_class)
-          mdc.put("resque_args", data.delete('args'))
-          
-          # add in any extra payload data, in case resque plugins have
-          # added to it (e.g. resque-lifecycle)
-          data.each do |k, v|
-            mdc.put("resque_payload_#{k}", v)
-          end
+        data = payload.clone
+        payload_class_name = data.delete('class')
+        payload_class = Resque.constantize(payload_class_name) rescue payload_class_name
+        
+        add_context(context, "resque_worker", worker)
+        add_context(context, "resque_queue", queue)
+        add_context(context, "resque_class", payload_class)
+        add_context(context, "resque_args", data.delete('args'))
+        
+        # add in any extra payload data, in case resque plugins have
+        # added to it (e.g. resque-lifecycle)
+        data.each do |k, v|
+          add_context(context, "resque_payload_#{k}", v)
+        end
 
+        error_logger = nil
+        if Log4rExceptionable::Configuration.use_source_logger
           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
-          
-          error_logger.error(exception)
-        ensure
-          # Since this is somewhat of a global map, clean the keys
-          # we put in so other log messages don't see them
-          mdc.get_context.keys.each do |k|
-            mdc.remove(k) unless original_mdc.has_key?(k)
           end
         end
         
-      rescue Exception => e
-        puts "Log4r Exceptionable could not log resque exception: " + e.message
+        error_logger ||= Log4rExceptionable::Configuration.resque_failure_logger
+        
+        error_logger.error(exception)
       end
+      
     end
 
     def self.count

data/lib/log4r-exceptionable/version.rb

@@ -1,3 +1,3 @@
 module Log4rExceptionable
-  VERSION = "0.5.4"
+  VERSION = "0.6.0"
 end

data/spec/rack_failure_handler_spec.rb

@@ -58,9 +58,12 @@ describe Log4rExceptionable::RackFailureHandler do
 
   context "handling rack failures" do
 
-    before(:all) do
+    before(:each) do
       Log4rExceptionable::Configuration.configure do |config|
         config.rack_failure_logger = 'racklogger'
+        config.use_source_logger = true
+        config.context_inclusions = nil
+        config.context_exclusions = nil
       end
     end
     
@@ -119,6 +122,20 @@ describe Log4rExceptionable::RackFailureHandler do
       }.should raise_error("I failed")
     end
     
+    it "uses default logger if source logger disabled" do
+      Log4rExceptionable::Configuration.use_source_logger = false
+      Log4r::Logger.new('ControllerLogger')
+      Log4r::Logger['ControllerLogger'].should_not_receive(:error)
+      Log4r::Logger['racklogger'].should_receive(:error) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+      end
+      
+      lambda {
+        get "/controller_logger"
+      }.should raise_error("I failed")
+    end
+    
     it "adds controller names if set" do
       Log4r::Logger.new('ControllerLogger')
       Log4r::Logger['ControllerLogger'].should_receive(:error) do |msg|
@@ -146,7 +163,6 @@ describe Log4rExceptionable::RackFailureHandler do
     end
     
     it "uses default logger if rack logger is not log4r" do
-      
       Log4r::Logger['racklogger'].should_receive(:error) do |msg|
         msg.should be_instance_of RuntimeError
         msg.message.should == "I failed"
@@ -170,6 +186,36 @@ describe Log4rExceptionable::RackFailureHandler do
       }.should raise_error("I failed")
     end
     
+    it "only includes inclusions if set" do
+      Log4rExceptionable::Configuration.context_inclusions = ['rack_env_rack.version']
+      
+      Log4r::Logger['racklogger'].should_receive(:error) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+        Log4r::MDC.get_context.keys.should == ['rack_env_rack.version']
+      end
+      
+      lambda {
+        get "/other_rack_logger"
+      }.should raise_error("I failed")
+      
+    end
+
+    it "excludes exclusions if set" do
+      Log4rExceptionable::Configuration.context_exclusions = ['rack_env_rack.version']
+      
+      Log4r::Logger['racklogger'].should_receive(:error) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+        Log4r::MDC.get_context.keys.should_not include 'rack_env_rack.version'
+      end
+      
+      lambda {
+        get "/other_rack_logger"
+      }.should raise_error("I failed")
+      
+    end
+
   end
   
 end

data/spec/resque_failure_handler_spec.rb

@@ -41,9 +41,12 @@ describe Log4rExceptionable::ResqueFailureHandler do
       end
     end
 
-    before(:all) do
+    before(:each) do
       Log4rExceptionable::Configuration.configure do |config|
         config.resque_failure_logger = 'resquelogger'
+        config.use_source_logger = true
+        config.context_inclusions = nil
+        config.context_exclusions = nil
       end
       
       Resque::Failure.backend = Log4rExceptionable::ResqueFailureHandler
@@ -98,6 +101,44 @@ describe Log4rExceptionable::ResqueFailureHandler do
       run_resque_job(SomeJobWithLogger, 'foo', :queue => :somequeue, :inline => true)
     end
     
+    it "uses default logger if source logger disabled" do
+      Log4rExceptionable::Configuration.use_source_logger = false
+      
+      Log4r::Logger.new('SomeJobWithLogger')
+      Log4r::Logger['SomeJobWithLogger'].should_not_receive(:error)
+      Log4r::Logger['resquelogger'].should_receive(:error) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+        Log4r::MDC.get('resque_class').should == SomeJobWithLogger
+      end
+      
+      run_resque_job(SomeJobWithLogger, 'foo', :queue => :somequeue, :inline => true)
+    end
+    
+    it "only includes inclusions if set" do
+      Log4rExceptionable::Configuration.context_inclusions = ['resque_queue']
+      
+      Log4r::Logger['resquelogger'].should_receive(:error) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+        Log4r::MDC.get_context.keys.should == ['resque_queue']
+      end
+      
+      run_resque_job(SomeJob, 'foo', :queue => :somequeue, :inline => true)
+    end
+
+    it "excludes exclusions if set" do
+      Log4rExceptionable::Configuration.context_exclusions = ['resque_queue']
+      
+      Log4r::Logger['resquelogger'].should_receive(:error) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+        Log4r::MDC.get_context.keys.should_not include 'resque_queue'
+      end
+      
+      run_resque_job(SomeJob, '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.4
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-15 00:00:00.000000000 Z
+date: 2012-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -126,6 +126,7 @@ files:
 - graylog2-resque.gemspec
 - lib/log4r-exceptionable.rb
 - lib/log4r-exceptionable/configuration.rb
+- lib/log4r-exceptionable/helper.rb
 - lib/log4r-exceptionable/rack_failure_handler.rb
 - lib/log4r-exceptionable/resque_failure_handler.rb
 - lib/log4r-exceptionable/version.rb