eh 0.0.3 → 0.0.5

data/.gitignore

@@ -16,3 +16,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+spec/test_spec.rb

data/README.md

@@ -4,17 +4,25 @@ The Error handler gem provides the following major functional support for error
 based on the ideas expressed in the Exceptional Ruby book by Avdi Grimm
 
 o Wrapping of code blocks in exception handling logic, supporting retry, logging and exception consumption, as well as a list of handlers that can be injected
+
 o Provision of fault tolerant logging that logs to configured logger(s), or to stderr should loggers be unavailable
+
 o Capability to handle unhandled exceptions, log them, email them and either raise them again or convert them to system exit codes (listing of standard linux exit codes provided as constants)
 
 The Error Handler gem allows the wrapping of arbitrary blocks of code in exception handling logic. Specifically, once an exception occurs:
 
 o The block can be retried 'threshold' times, with a delay of 'delay' seconds in-between retries (EH::retry and EH::retry!)
+
 o The exception can be logged to a single logger, or an array of loggers
+
 o The exception can be re-raised (suppressed during retry, but logged, raised again after retry failure)
+
 o The same functionality is available, with retry disabled (EH::run and EH::run!)
+
 o The list of Linux system exit codes is also provided as EH::EX_<exit>
+
 o Unhandled exceptions can be logged and emailed in main() using EH::report_unhandled()
+
 o A list of handlers can be injected to do custom handling, such as email, roll-back, etc.
 
 This gem is sponsored by Hetzner (Pty) Ltd - http://hetzner.co.za
@@ -35,72 +43,81 @@ Or install it yourself as:
 
 ## Usage
 
-require 'rubygems'
-require 'eh/eh'
+    require 'rubygems'
+    require 'eh/eh'
 
 -- Run code block with retry, logging and exception re-raise, specifying logger, number of
    times to retry, retry delay, and block arguments. Also call handle(exception, message) on
    the list of handlers provided
-def load_configuration(configuration_path, logger = nil)
-  EH::retry!(:logger => logger,
-             :message => "Could not parse YAML configuration",
-             :args => [configuration_path],
-             :threshold => 5,
-             :delay => 0.5,
-             :exception_filter => [RuntimeError, IOError],
-             :handlers => [MyEmailHandler.new, MyOtherHandler.new]) do
-      YAML.load(File.open(configuration_path))
-  end
-end
+
+    def load_configuration(configuration_path, logger = nil)
+        EH::retry!(:logger => logger,
+                  :message => "Could not parse YAML configuration",
+                  :args => [configuration_path],
+                  :threshold => 5,
+                  :delay => 0.5,
+                  :exception_filter => [RuntimeError, IOError],
+                  :handlers => [MyEmailHandler.new, MyOtherHandler.new]) do
+            YAML.load(File.open(configuration_path))
+        end
+    end
 
 -- Run code block with retry only on the exceptions listed, with the default threshold and delay
 
-def load_configuration(configuration_path, logger = nil)
-  EH::retry!(:args => [configuration_path], :exceptions => [IOError, RuntimeError]) do
-      YAML.load(File.open(configuration_path))
-  end
-end
+    def load_configuration(configuration_path, logger = nil)
+        EH::retry!(:args => [configuration_path], :exceptions => [IOError, RuntimeError]) do
+            YAML.load(File.open(configuration_path))
+        end
+    end
 
 -- Run code block without retry, and swallowing all exceptions
 
-def load_configuration(configuration_path, logger = nil)
-  EH::run(:args => [configuration_path]) do
-      YAML.load(File.open(configuration_path))
-  end
-end
+    def load_configuration(configuration_path, logger = nil)
+        EH::run(:args => [configuration_path]) do
+            YAML.load(File.open(configuration_path))
+        end
+    end
 
 Any combination of the following options are allowed, both with both flavours of run() and retry().
 
-:logger - log using the logger's error() method
-:message - log this message, with the exception appended
-:args - code block arguments
-:threshold - the number of execution attempts
-:delay - the number of seconds to delay between retries
-:handlers - an array of handlers that implement handle(exception, message)
+    :logger - log using the logger's error() method
+    :message - log this message, with the exception appended
+    :args - code block arguments
+    :threshold - the number of execution attempts
+    :delay - the number of seconds to delay between retries
+    :handlers - an array of handlers that implement handle(exception, message)
 
 Function descriptions:
 
 run - Execute block, swallow all exceptions, no retry
+
 run! - Execute block, re-raise exceptions, no retry
+
 retry - Execute block, swallow all exceptions, retry
+
 retry! - Execute block, re-raise exceptions, retry
 
 Exception filters:
 
 When :exception_filter is provided to retry!(), only the exceptions in the filter are retried. If retry fails, all exceptions are re-raised.
+
 When :exception_filter is provided to retry(), only the exceptions in the filter are retried. If retry fails. Exceptions are not re-raised.
+
 When :exception_filter is provided to run!(), only the exceptions in the filter are logged, if a logger is provided. All exceptions are re-raised.
+
 When :exception_filter is provided to run(), only the exceptions in the filter are logged, if a logger is provided. Exceptions are not re-raised.
 
 Unhandled exceptions can be logged and emailed as follows:
 
-at_exit do
-  EH::report_unhandled(logfile = "/var/log/myapp/crash.log", email = "ernst.van.graan@hetzner.co.za")
-  exit EH::EX_CONFIG
-end
+    at_exit do
+        EH::report_unhandled(logfile = "/var/log/myapp/crash.log", email = "ernst.van.graan@hetzner.co.za")
+        exit EH::EX_CONFIG
+    end
 
 Please send feedback and comments to the authors at:
+
 Ernst van Graan <ernst.van.graan@hetzner.co.za>
+
 Wynand van Dyk <wynand.van.dyk@hetzner.co.za>
 
 ## Contributing

data/lib/eh/eh.rb

@@ -16,6 +16,7 @@ module ErrorHandler
     EX_TEMPFAIL    = 75; EX_TEMPFAIL.freeze    # temp failure; user is invited to retry
     EX_PROTOCOL    = 76; EX_PROTOCOL.freeze    # remote error in protocol
     EX_NOPERM      = 77; EX_NOPERM.freeze      # permission denied
+    EX_CONFIG      = 78; EX_CONFIG.freeze      # configuration error
 
     ERROR = 'error'
     DEBUG = 'debug'
@@ -23,22 +24,19 @@ module ErrorHandler
     WARN = 'warn'
     FATAL = 'fatal'
 
-    # Coming soon...
-    #def self.report_unhandled(logfile = nil, email = nil)
-    #  if $!
-    #    message = "Unhandled exception: #{$!}"
-    #    warn message
-    #    if not logfile.nil?
-    #      open(logfile, 'a') { |f|
-    #        f.puts message
-    #      }
-    #    end
-    #
-    #    if not email.nil?
-    #      send_email(email, message)
-    #    end
-    #  end
-    #end
+    def self.report_unhandled(logfile = nil, handlers = nil)
+      if $!
+        message = "Unhandled exception: #{$!}"
+        warn message
+        if not logfile.nil?
+          open(logfile, 'a') { |f|
+            f.puts message
+          }
+        end
+
+        handle(handlers, $!, message) if not handlers.nil?
+      end
+    end
 
     def self.retry!(options, &block)
       opts = options || {}

data/lib/eh/version.rb

@@ -1,3 +1,3 @@
 module ErrorHandler
-  VERSION = "0.0.3"
+  VERSION = "0.0.5"
 end

data/spec/eh_spec.rb

@@ -478,5 +478,4 @@ describe ErrorHandler do
       EH::log([nil, @logger], "fatal", EH::FATAL)
     end
   end
-
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: eh
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 21
   prerelease: 
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Ernst van Graan, Wynand van Dyk
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-03-07 00:00:00 Z
+date: 2013-03-14 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: bundler