log4r-exceptionable 0.7.0 → 0.8.0

data/.travis.yml

@@ -1,10 +1,7 @@
 language: ruby
 rvm:
-  - 1.8.7
   - 1.9.2
   - 1.9.3
-  - jruby-18mode # JRuby in 1.8 mode
   - jruby-19mode # JRuby in 1.9 mode
-  # - rbx-18mode
   # - rbx-19mode
 script: bundle exec rspec spec

data/lib/log4r-exceptionable.rb

@@ -9,6 +9,12 @@ begin
 rescue LoadError
 end
 
+# optional if only using sidekiq
+begin
+  require "log4r-exceptionable/sidekiq_failure_handler"
+rescue LoadError
+end
+
 # optional if only using rack
 begin
   require "log4r-exceptionable/resque_failure_handler"

data/lib/log4r-exceptionable/configuration.rb

@@ -6,7 +6,7 @@ module Log4rExceptionable
 
     class << self
       # required - default loggers used if source logger not available
-      attr_accessor :rack_failure_logger, :resque_failure_logger
+      attr_accessor :rack_failure_logger, :resque_failure_logger, :sidekiq_failure_logger
       # Allows one to force use of default loggers by setting to false
       attr_accessor :use_source_logger
       # The level to log exceptions
@@ -15,17 +15,20 @@ module Log4rExceptionable
       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
+      # Swallow exceptions raised by the call to the logger, printing to stderr, defaults to true
+      attr_accessor :failsafe_logging
     end
 
     # default values
     self.use_source_logger = true
     self.log_level = :fatal
+    self.failsafe_logging = true
 
     def self.configure
       yield self
 
-      if ! self.rack_failure_logger && ! self.resque_failure_logger
-        raise "log4r-exceptionable requires a rack_failure_logger or resque_failure_logger"
+      if ! self.rack_failure_logger && ! self.resque_failure_logger && ! self.sidekiq_failure_logger
+        raise "log4r-exceptionable requires a rack_failure_logger or resque_failure_logger or sidekiq_failure_logger"
       end
 
       if self.rack_failure_logger
@@ -36,6 +39,10 @@ module Log4rExceptionable
         self.set_logger(:resque_failure_logger)
       end
       
+      if self.sidekiq_failure_logger
+        self.set_logger(:sidekiq_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
 

data/lib/log4r-exceptionable/helper.rb

@@ -20,7 +20,8 @@ module Log4rExceptionable
         end
         
       rescue => e
-        $stderr.puts "Log4r Exceptionable could not log exception: " + e.message
+        raise e unless Log4rExceptionable::Configuration.failsafe_logging
+        $stderr.puts "Log4r Exceptionable could not log exception: #{e.class} #{e.message}"
       end
     end
 

data/lib/log4r-exceptionable/sidekiq_failure_handler.rb

@@ -0,0 +1,51 @@
+require 'sidekiq'
+
+module Log4rExceptionable
+    
+  # A Resque Failure backend that logs exceptions with log4r
+  #
+  class SidekiqFailureHandler
+    include Log4rExceptionable::Helper
+    
+    def call(worker, msg, queue)
+      begin
+        yield
+      rescue => ex
+        log_exception(worker, queue, ex, msg)
+        raise
+      end
+    end
+  
+    def log_exception(worker, queue, ex, msg)
+      
+      log_with_context do |context|
+        
+        add_context(context, "sidekiq_worker", worker.class)
+        add_context(context, "sidekiq_queue", queue.to_s)
+        add_context(context, "sidekiq_args", msg['args'])
+        add_context(context, "sidekiq_jid", worker.jid)
+        
+        # add in any extra payload data
+        msg.each do |k, v|
+          next if %w[class args].include?(k)
+          add_context(context, "sidekiq_msg_#{k}", v)
+        end
+
+        error_logger = nil
+        if Log4rExceptionable::Configuration.use_source_logger
+          payload_class = worker.logger rescue nil
+          if worker.logger.instance_of?(Log4r::Logger)
+            error_logger = worker.logger
+          end
+        end
+        
+        error_logger ||= Log4rExceptionable::Configuration.sidekiq_failure_logger
+        
+        error_logger.send(Log4rExceptionable::Configuration.log_level, ex)
+      end
+      
+    end
+
+  end
+    
+end

data/lib/log4r-exceptionable/version.rb

@@ -1,3 +1,3 @@
 module Log4rExceptionable
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/{graylog2-resque.gemspec → log4r-exceptionable.gemspec}

@@ -25,5 +25,6 @@ Gem::Specification.new do |s|
   
   s.add_development_dependency("rack-test")
   s.add_development_dependency("resque")
+  s.add_development_dependency("sidekiq")
   s.add_dependency("log4r")
 end

data/spec/configuration_spec.rb

@@ -7,13 +7,14 @@ describe Log4rExceptionable::Configuration do
     before(:each) do
       Log4rExceptionable::Configuration.rack_failure_logger = nil
       Log4rExceptionable::Configuration.resque_failure_logger = nil
+      Log4rExceptionable::Configuration.sidekiq_failure_logger = nil
     end
     
     it "should raise if no logger in config" do
       lambda {
         Log4rExceptionable::Configuration.configure do |config|
         end
-      }.should raise_error("log4r-exceptionable requires a rack_failure_logger or resque_failure_logger")
+      }.should raise_error("log4r-exceptionable requires a rack_failure_logger or resque_failure_logger or sidekiq_failure_logger")
     end
 
     it "should not raise if config has a rack logger" do

data/spec/helper_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Log4rExceptionable::Helper do
+  include Log4rExceptionable::Helper
+  
+  context "helper" do
+
+    before(:each) do
+    end
+    
+    it "should raise if failsafe_logging false" do
+      Log4rExceptionable::Configuration.failsafe_logging = false
+      $stderr.should_not_receive(:puts)
+
+      lambda {
+        log_with_context do
+          raise "I failed"
+        end
+      }.should raise_error("I failed")
+    end
+    
+    it "should not raise if failsafe_logging true" do
+      Log4rExceptionable::Configuration.failsafe_logging = true
+      $stderr.should_receive(:puts)
+
+      
+      lambda {
+        log_with_context do
+          raise "I failed"
+        end
+      }.should_not raise_error("I failed")
+    end
+
+  end
+  
+end

data/spec/resque_failure_handler_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 describe Log4rExceptionable::ResqueFailureHandler do
-  include PerformJob
+  include PerformResqueJob
 
   context "handling resque failures" do
 
@@ -65,7 +65,7 @@ describe Log4rExceptionable::ResqueFailureHandler do
         Log4r::MDC.get('resque_args').should == ["foo"]
       end
       
-      run_resque_job(SomeJob, 'foo', :queue => :somequeue, :inline => true)
+      run_job(SomeJob, 'foo', :queue => :somequeue, :inline => true)
     end
     
     it "uses default logger if job logger is nil" do
@@ -76,7 +76,7 @@ describe Log4rExceptionable::ResqueFailureHandler do
         Log4r::MDC.get('resque_class').should == SomeJobWithNilLogger
       end
       
-      run_resque_job(SomeJobWithNilLogger, 'foo', :queue => :somequeue, :inline => true)
+      run_job(SomeJobWithNilLogger, 'foo', :queue => :somequeue, :inline => true)
     end
     
     it "uses default logger if job logger is not log4r" do
@@ -87,7 +87,7 @@ describe Log4rExceptionable::ResqueFailureHandler do
         Log4r::MDC.get('resque_class').should == SomeJobWithOtherLogger
       end
       
-      run_resque_job(SomeJobWithOtherLogger, 'foo', :queue => :somequeue, :inline => true)
+      run_job(SomeJobWithOtherLogger, 'foo', :queue => :somequeue, :inline => true)
     end
     
     it "uses job logger if set" do
@@ -99,7 +99,7 @@ describe Log4rExceptionable::ResqueFailureHandler do
         Log4r::MDC.get('resque_class').should == SomeJobWithLogger
       end
       
-      run_resque_job(SomeJobWithLogger, 'foo', :queue => :somequeue, :inline => true)
+      run_job(SomeJobWithLogger, 'foo', :queue => :somequeue, :inline => true)
     end
     
     it "uses default logger if source logger disabled" do
@@ -113,7 +113,7 @@ describe Log4rExceptionable::ResqueFailureHandler do
         Log4r::MDC.get('resque_class').should == SomeJobWithLogger
       end
       
-      run_resque_job(SomeJobWithLogger, 'foo', :queue => :somequeue, :inline => true)
+      run_job(SomeJobWithLogger, 'foo', :queue => :somequeue, :inline => true)
     end
     
     it "only includes inclusions if set" do
@@ -125,7 +125,7 @@ describe Log4rExceptionable::ResqueFailureHandler do
         Log4r::MDC.get_context.keys.should == ['resque_queue']
       end
       
-      run_resque_job(SomeJob, 'foo', :queue => :somequeue, :inline => true)
+      run_job(SomeJob, 'foo', :queue => :somequeue, :inline => true)
     end
 
     it "excludes exclusions if set" do
@@ -137,7 +137,7 @@ describe Log4rExceptionable::ResqueFailureHandler do
         Log4r::MDC.get_context.keys.should_not include 'resque_queue'
       end
       
-      run_resque_job(SomeJob, 'foo', :queue => :somequeue, :inline => true)
+      run_job(SomeJob, 'foo', :queue => :somequeue, :inline => true)
     end
     
     it "logs with given log_level" do
@@ -148,7 +148,7 @@ describe Log4rExceptionable::ResqueFailureHandler do
         msg.message.should == "I failed"
       end
       
-      run_resque_job(SomeJob, 'foo', :queue => :somequeue, :inline => true)
+      run_job(SomeJob, 'foo', :queue => :somequeue, :inline => true)
     end
     
     

data/spec/sidekiq_failure_handler_spec.rb

@@ -0,0 +1,178 @@
+require "spec_helper"
+
+describe Log4rExceptionable::SidekiqFailureHandler do
+  include PerformSidekiqJob
+
+  context "handling sidekiq failures" do
+
+    class SomeJob
+      include Sidekiq::Worker
+      def perform(*args)
+        raise "I failed"
+      end
+    end
+
+    class SomeJobWithNilLogger
+      include Sidekiq::Worker
+      def logger
+        nil
+      end
+      
+      def perform(*args)
+        raise "I failed"
+      end
+    end
+
+    class SomeJobWithOtherLogger
+      include Sidekiq::Worker
+      def logger
+        self
+      end
+      
+      def perform(*args)
+        raise "I failed"
+      end
+    end
+    
+    class SomeJobWithLogger
+      include Sidekiq::Worker
+      def logger
+        Log4r::Logger["SomeJobWithLogger"] || Log4r::Logger.new("SomeJobWithLogger")
+      end
+      
+      def perform(*args)
+        raise "I failed"
+      end
+    end
+
+    before(:each) do
+      Sidekiq.server_middleware do |chain|
+        chain.insert_before Sidekiq::Middleware::Server::Logging, Log4rExceptionable::SidekiqFailureHandler
+      end
+      
+      Log4rExceptionable::Configuration.configure do |config|
+        config.sidekiq_failure_logger = 'sidekiqlogger'
+        config.use_source_logger = true
+        config.context_inclusions = nil
+        config.context_exclusions = nil
+        config.log_level = :fatal
+      end
+    end
+    
+    it "triggers failure handler" do
+      
+      Log4r::Logger['sidekiqlogger'].should_receive(:fatal) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+        msg.backtrace.first.should =~ /sidekiq_failure_handler_spec.rb/
+        Log4r::MDC.get('sidekiq_worker').should == SomeJob
+        Log4r::MDC.get('sidekiq_queue').should == "somequeue"
+        Log4r::MDC.get('sidekiq_args').should == ["foo"]
+      end
+      
+      lambda {
+        run_job(SomeJob, 'foo', :queue => :somequeue)
+      }.should raise_error("I failed")
+    end
+    
+    it "uses default logger if job logger is nil" do
+      
+      Log4r::Logger['sidekiqlogger'].should_receive(:fatal) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+        Log4r::MDC.get('sidekiq_worker').should == SomeJobWithNilLogger
+      end
+      
+      lambda {
+        run_job(SomeJobWithNilLogger, 'foo', :queue => :somequeue)
+      }.should raise_error("I failed")
+    end
+    
+    it "uses default logger if job logger is not log4r" do
+      
+      Log4r::Logger['sidekiqlogger'].should_receive(:fatal) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+        Log4r::MDC.get('sidekiq_worker').should == SomeJobWithOtherLogger
+      end
+      
+      lambda {
+        run_job(SomeJobWithOtherLogger, 'foo', :queue => :somequeue)
+      }.should raise_error("I failed")
+    end
+    
+    it "uses job logger if set" do
+      Log4r::Logger.new('SomeJobWithLogger')
+      Log4r::Logger['sidekiqlogger'].should_not_receive(:fatal)
+      Log4r::Logger['SomeJobWithLogger'].should_receive(:fatal) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+        Log4r::MDC.get('sidekiq_worker').should == SomeJobWithLogger
+      end
+      
+      lambda {
+        run_job(SomeJobWithLogger, 'foo', :queue => :somequeue)
+      }.should raise_error("I failed")
+    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(:fatal)
+      Log4r::Logger['sidekiqlogger'].should_receive(:fatal) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+        Log4r::MDC.get('sidekiq_worker').should == SomeJobWithLogger
+      end
+      
+      lambda {
+        run_job(SomeJobWithLogger, 'foo', :queue => :somequeue)
+      }.should raise_error("I failed")
+    end
+    
+    it "only includes inclusions if set" do
+      Log4rExceptionable::Configuration.context_inclusions = ['sidekiq_queue']
+      
+      Log4r::Logger['sidekiqlogger'].should_receive(:fatal) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+        Log4r::MDC.get_context.keys.should == ['sidekiq_queue']
+      end
+      
+      lambda {
+        run_job(SomeJob, 'foo', :queue => :somequeue)
+      }.should raise_error("I failed")
+    end
+    
+    it "excludes exclusions if set" do
+      Log4rExceptionable::Configuration.context_exclusions = ['sidekiq_queue']
+      
+      Log4r::Logger['sidekiqlogger'].should_receive(:fatal) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+        Log4r::MDC.get_context.keys.should_not include 'sidekiq_queue'
+      end
+      
+      lambda {
+        run_job(SomeJob, 'foo', :queue => :somequeue)
+      }.should raise_error("I failed")
+    end
+    
+    it "logs with given log_level" do
+      Log4rExceptionable::Configuration.log_level = :info
+      
+      Log4r::Logger['sidekiqlogger'].should_receive(:info) do |msg|
+        msg.should be_instance_of RuntimeError
+        msg.message.should == "I failed"
+      end
+      
+      lambda {
+        run_job(SomeJob, 'foo', :queue => :somequeue)
+      }.should raise_error("I failed")
+    end
+    
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -1,6 +1,9 @@
 require "rack/test"
 require 'rspec'
 require 'resque'
+require 'sidekiq'
+require 'sidekiq/processor'
+require 'sidekiq/fetch'
 require 'log4r-exceptionable'
 require 'ap'
 
@@ -26,24 +29,28 @@ unless ENV['CI']
       File.delete("#{spec_dir}/dump.rdb") rescue nil
     end
   end
-  
+
+end
+
+RSpec.configure do |config|
+  config.before(:each) { Log4rExceptionable::Configuration.failsafe_logging = false }
 end
 
 ##
 # Helper to perform job classes
 #
-module PerformJob
+module PerformResqueJob
 
-  def run_resque_job(job_class, *job_args)
+  def run_job(job_class, *job_args)
     opts = job_args.last.is_a?(Hash) ? job_args.pop : {}
     queue = opts[:queue] || Resque.queue_from_class(job_class)
 
     Resque::Job.create(queue, job_class, *job_args)
 
-    run_resque_queue(queue, opts)
+    run_queue(queue, opts)
   end
 
-  def run_resque_queue(queue, opts={})
+  def run_queue(queue, opts={})
     worker = Resque::Worker.new(queue)
     worker.very_verbose = true if opts[:verbose]
 
@@ -76,3 +83,37 @@ module PerformJob
   end
 
 end
+
+Celluloid.logger = nil
+
+module PerformSidekiqJob
+
+  def run_job(job_class, *job_args)
+    opts = job_args.last.is_a?(Hash) ? job_args.pop : {}
+    queue = (opts[:queue] || 'testqueue').to_s
+    
+    Sidekiq.logger = mock().as_null_object
+    @boss = stub()
+    @processor = ::Sidekiq::Processor.new(@boss)
+    #Sidekiq.redis = REDIS
+    
+    msg = Sidekiq.dump_json({ 'class' => job_class.to_s, 'args' => job_args })
+    @processor.process(::Sidekiq::BasicFetch::UnitOfWork.new(queue, msg))
+    @boss.verify
+  end
+
+  def dump_redis
+    result = {}
+    Sidekiq.redis.keys("*").each do |key|
+      type = Sidekiq.redis.type(key)
+      result[key] = case type
+        when 'string' then Sidekiq.redis.get(key)
+        when 'list' then Sidekiq.redis.lrange(key, 0, -1)
+        when 'set' then Sidekiq.redis.smembers(key)
+        else type
+      end
+    end
+    return result
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: log4r-exceptionable
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-21 00:00:00.000000000 Z
+date: 2013-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -91,6 +91,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: log4r
   requirement: !ruby/object:Gem::Requirement
@@ -123,17 +139,20 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- 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/sidekiq_failure_handler.rb
 - lib/log4r-exceptionable/version.rb
+- log4r-exceptionable.gemspec
 - spec/configuration_spec.rb
+- spec/helper_spec.rb
 - spec/rack_failure_handler_spec.rb
 - spec/redis-test.conf
 - spec/resque_failure_handler_spec.rb
+- spec/sidekiq_failure_handler_spec.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses: []
@@ -147,22 +166,29 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 391045047313925202
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 391045047313925202
 requirements: []
 rubyforge_project: log4r-exceptionable
-rubygems_version: 1.8.21
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Failure handlers for rack and resque that log failures using log4r
 test_files:
 - spec/configuration_spec.rb
+- spec/helper_spec.rb
 - spec/rack_failure_handler_spec.rb
 - spec/redis-test.conf
 - spec/resque_failure_handler_spec.rb
+- spec/sidekiq_failure_handler_spec.rb
 - spec/spec_helper.rb
-has_rdoc: