ixtlan-error-handler 0.1.1 → 0.2.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Kristian Meier
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,31 @@
+h1. Rails Error Dumper
+
+p. the main idea here is notify the developers on error but in a way to protect privacy of the users of the system. to do so ALL data need to remain on the server and they need to be deleted after period of time.
+
+* first to dump as much as possible onto the filesystem of the server when an error occurs, i.e. the environment, the request, the response, the session, etc
+
+* notify the developers
+
+* delete expired error dumps
+
+p. the next idea is to collect all possible rails exception and map them to three error pages and pass on a message. for each exception you can decide whether an error dump is needed or not.
+
+h2. install
+
+p. in Gemfile add *gem 'ixtlan-error-handler'*
+
+p. for the configuration add for example in _config/initializers/error_handler.rb_
+
+bc. config.error_dumper.dump_dir = Rails.root + "/log/errors" # default: log/errors
+config.error_dumper.email_from = "no-reply@example.com"
+config.error_dumper.email_to = "developer1@example.com,developer2@example.com"
+config.error_dumper.keep_dumps = 30 # days
+config.skip_rescue_module = true # do not include the predefined Rescue 
+
+h2. relation to ixtlan gem
+
+p. the ixtlan gem provides a setup generator which adds configuration examples for this gem in _config/initializer/ixtlan.rb_ (the dynamic configuration is part of the ixtlan gem and it is just easier to keep that inside that gem !!!)
+
+h2. relation to ixtlan-audit gem
+
+p. if that gem is present and loaded than any error will be log with the help of _Ixtlan::Audit::UserLogger_

data/lib/ixtlan/errors/error_dumper.rb

@@ -1,85 +1,110 @@
 require 'ixtlan/errors/mailer'
 require 'fileutils'
+require 'slf4r/logger'
+
+# unless Fixnum.respond_to? :days
+#   class Fixnum
+#     def days
+#       self
+#     end
+    
+#     def ago
+#       DateTime.now - 86000 * self
+#     end
+#   end
+# end
 
 module Ixtlan
   module Errors
     class ErrorDumper
       
-      attr_accessor :dump_dir, :email_from, :email_to, :keep_dumps
+      private
+
+      include ::Slf4r::Logger
+
+      public
+
+      attr_accessor :from_email, :to_emails, :keep_dumps, :base_url
 
-      def keep_dumps
-        @keep_dumps ||= 90
+      def initialize
+        @keep_dumps = 30
       end
 
       def keep_dumps=(ttl)
+        old = @keep_dumps
         @keep_dumps = ttl.to_i
-        cleanup
+        daily_cleanup if old != @keep_dumps
       end
-
-      def dump_dir
-        if @dump_dir.blank?
-          @dump_dir = File.join(Rails.root, "log", "errors")
-          FileUtils.mkdir_p(@dump_dir)
-        end
-        @dump_dir 
+      
+      def error_dump_model(model = nil)
+        @error_dump ||= model.nil? ? ::Error : model.classify
       end
 
-      def dump_dir=(dir)
-        @dump_dir = dir
-        FileUtils.mkdir_p(@dump_dir) unless dir.blank?
-        @dump_dir
-      end
-      
       def dump(controller, exception)
-        cleanup
-        log_file = log_filename
-        logger = Logger.new(log_file)
+        daily_cleanup
 
-        dump_environment(logger, exception, controller)
-        Mailer.error_notification(@email_from, @email_to, exception, log_file).deliver unless (@email_to.blank? || @email_from.blank?)
-        log_file
+        error = dump_environment(exception, controller)
+        Mailer.error_notification(@from_email, @to_emails, exception, "#{@base_url}/#{error.id}").deliver unless (@to_emails.blank? || @from_email.blank?)
+        "#{@base_url}/#{error.id}"
       end
 
       private
 
-      def log_filename(time = Time.now)
-        error_log_id = "#{time.tv_sec}#{time.tv_usec}"
-        File.join(dump_dir, "error-#{error_log_id}.log")
-      end
+      def dump_environment(exception, controller)
+        dump = error_dump_model.new
+        
+        dump.request = dump_hashmap(controller.request.env)
 
-      def dump_environment_header(logger, header)
-        logger.error("\n===================================================================\n#{header}\n===================================================================\n");
-      end
+        dump.response = dump_hashmap(controller.response.headers)
 
-      def dump_environment(logger, exception, controller)
-        dump_environment_header(logger, "REQUEST DUMP");
-        dump_hashmap(logger, controller.request.env)
+        dump.session = dump_hashmap(controller.session)
 
-        dump_environment_header(logger, "RESPONSE DUMP");
-        dump_hashmap(logger, controller.response.headers)
+        dump.parameters = dump_hashmap(controller.params)
 
-        dump_environment_header(logger, "SESSION DUMP");
-        dump_hashmap(logger, controller.session)
+        dump.message = exception.message
+        
+        dump.clazz = exception.class.to_s
+        
+        dump.backtrace = exception.backtrace.join("\n") if exception.backtrace
 
-        dump_environment_header(logger, "PARAMETER DUMP");
-        map = {}
-        dump_hashmap(logger, controller.params.each{ |k,v| map[k]=v })
+        dump if dump.save
+      end
 
-        dump_environment_header(logger, "EXCEPTION");
-        logger.error("#{exception.class}:#{exception.message}")
-        logger.error("\t" + exception.backtrace.join("\n\t")) if exception.backtrace
+      def dump_hashmap(map, indent = '')
+        result = ''
+        map.each do |key,value|
+          if value.is_a? Hash
+            result << "#{indent}#{key} => {\n"
+            result << dump_hashmap(value, "#{indent}  ") 
+            result << "#{indent}}\n"
+          else
+            result << "#{indent}#{key} => #{value.nil? ? 'nil': value}\n"
+          end
+        end
+        result
       end
 
-      def dump_hashmap(logger, map)
-        for key,value in map
-          logger.error("\t#{key} => #{value.inspect}")
+      def daily_cleanup
+        if(@last_cleanup.nil? || @last_cleanup < 1.days.ago)
+          @last_cleanup = 0.days.ago # to have the right type
+          begin
+            delete_all
+            logger.info("cleaned error dumps")
+          rescue Exception => e
+            logger.error("cleanup error dumps", e)
+          end
         end
       end
 
-      def cleanup
-        ref_log_file = log_filename(keep_dumps.ago)
-        Dir[File.join(dump_dir, "error-*.log")].each do |f|
-          FileUtils.rm(f) if File.basename(f) < ref_log_file
+      private
+      
+      if defined? ::DataMapper
+        def delete_all
+          error_dump_model.all(:created_at.lte => keep_dumps.days.ago).destroy!
+        end
+      else # ActiveRecord
+        def delete_all
+          error_dump_model.all(:conditions => ["created_at <= ?", keep_dumps.days.ago]).each(&:delete)
         end
       end
     end

data/lib/ixtlan/errors/error_dumper.rb~

@@ -0,0 +1,79 @@
+module Ixtlan
+  module Errors
+    class ErrorDumper
+
+      def initialize
+        configure
+      end
+
+      def configure(error_dir = nil, email_from = nil, emails_to = nil, time_to_live = 90)
+        if config
+          @email_from = email_from
+          @email_to = emails_to
+          @errors_dir = errors_dir
+        else
+          @email_from = nil
+          @email_to = nil
+        end
+        
+        @time_to_live = time_to_live
+        @errors_dir ||= File.join(Rails.root, "log", "errors")
+        FileUtils.mkdir_p(@errors_dir)
+        cleanup
+      end
+
+      def dump(controller, exception)
+        cleanup
+        log_file = log_filename
+        logger = Logger.new(log_file)
+
+        dump_environment(logger, exception, controller)
+        Mailer.deliver_error_notification(@email_from, @email_to, exception, log_file) unless (@email_to.blank? || @email_from.blank?)
+        log_file
+      end
+
+      private
+
+      def log_filename(time = Time.now)
+        error_log_id = "#{time.tv_sec}#{time.tv_usec}"
+        File.join(@errors_dir, "error-#{error_log_id}.log")
+      end
+
+      def dump_environment_header(logger, header)
+        logger.error("\n===================================================================\n#{header}\n===================================================================\n");
+      end
+
+      def dump_environment(logger, exception, controller)
+        dump_environment_header(logger, "REQUEST DUMP");
+        dump_hashmap(logger, controller.request.env)
+
+        dump_environment_header(logger, "RESPONSE DUMP");
+        dump_hashmap(logger, controller.response.headers)
+
+        dump_environment_header(logger, "SESSION DUMP");
+        dump_hashmap(logger, controller.session)
+
+        dump_environment_header(logger, "PARAMETER DUMP");
+        map = {}
+        dump_hashmap(logger, controller.params.each{ |k,v| map[k]=v })
+
+        dump_environment_header(logger, "EXCEPTION");
+        logger.error("#{exception.class}:#{exception.message}")
+        logger.error("\t" + exception.backtrace.join("\n\t"))
+      end
+
+      def dump_hashmap(logger, map)
+        for key,value in map
+          logger.error("\t#{key} => #{value.inspect}")
+        end
+      end
+
+      def cleanup
+        ref_log_file = log_filename(@time_to_live.ago)
+        Dir[File.join(@error_dir, "error-*.log")].each do |f|
+          FileUtils.rm(f) if File.basename(f) < ref_log_file
+        end
+      end
+    end
+  end
+end

data/lib/ixtlan/errors/error_handler.rb

@@ -14,23 +14,12 @@ module Ixtlan
         log_user_error(exception)
         error_page(:not_found, "page not found")
       end
-        #status = rescue_responses[exception.class.name]
-        #status = status == :internal_server_error ? :not_found : status
-        #error_page(status, "page not found")
 
       def stale_resource(exception)
         log_user_error(exception)
         error_page(:conflict, "stale resource")
       end
 
-      #   respond_to do |format|
-      #     format.html {
-      #       render_stale_error_page
-      #     }
-      #     format.xml { head :conflict }
-      #   end
-      # end
-
       def render_error_page_with_session(status)
         render :template => "errors/error_with_session", :status => status
       end
@@ -39,10 +28,6 @@ module Ixtlan
         render :template => "errors/error", :status => status
       end
 
-      # def render_stale_error_page
-      #   render :template => "errors/stale", :status => :conflict
-      # end
-
       private
 
       if defined? ::Ixtlan::Audit

data/lib/ixtlan/errors/error_handler.rb~

@@ -0,0 +1,79 @@
+module Ixtlan
+  module Errors
+    module ErrorHandling
+
+      protected
+
+      def internal_server_error(exception)
+        dump_error(exception)
+        status = :internal_server_error
+        error_page(:internal_server_error, exception, "internal server error: #{exception.class.name}")
+        end
+      end
+
+      def page_not_found(exception)
+        log_user_error(exception)
+        status = rescue_responses[exception.class.name]
+        status = status == :internal_server_error ? :not_found : status
+        error_page(status, exception, "page not found")
+      end
+
+      def stale_resource(exception)
+        log_user_error(exception)
+        respond_to do |format|
+          format.html {
+            render_stale_error_page
+          }
+          format.xml { head :conflict }
+        end
+      end
+
+      def render_error_page_with_session(status)
+        render :template => "errors/error_with_session", :status => status
+      end
+
+      def render_error_page(status)
+        render :template => "errors/error", :status => status
+      end
+
+      def render_stale_error_page
+        render :template => "errors/stale", :status => :conflict
+      end
+
+      private
+
+      if defined? ::Ixtlan::Audit
+        def user_logger
+          @user_logger ||= Ixtlan::Audit::UserLogger.new(ErrorHandling)
+        end
+
+        def log_user_error(exception)
+          user_logger.log_action(self, " - #{exception.class} - #{exception.message}")
+          log_error(exception)
+        end
+      else
+        alias :log_user_error :log_error
+      end
+
+      def error_page(status, exception, notice)
+        respond_to do |format|
+          format.html {
+            @notice = notice
+            if logged_in?
+              render_error_page_with_session(status)
+            else
+              render_error_page(status)
+            end
+          }
+          # TODO add the notice there as well. how ?
+          format.xml { head status }
+        end
+      end
+
+      def dump_error(exception)
+        log_user_error(exception)
+        Rails.configuration.error_dumper.dump(self, exception)
+      end
+    end
+  end
+end

data/lib/ixtlan/errors/error_handling.rb~

@@ -0,0 +1,79 @@
+module Ixtlan
+  module Errors
+    module ErrorHandling
+
+      protected
+
+      def internal_server_error(exception)
+        dump_error(exception)
+        status = :internal_server_error
+        error_page(:internal_server_error, exception) do |exception|
+          "internal server error: #{exception.class.name}"
+        end
+      end
+
+      def page_not_found(exception)
+        log_user_error(exception)
+        status = rescue_responses[exception.class.name]
+        status = status == :internal_server_error ? :not_found : status
+        error_page(status, exception) { "page not found" }
+      end
+
+      def stale_resource(exception)
+        log_user_error(exception)
+        respond_to do |format|
+          format.html {
+            render_stale_error_page
+          }
+          format.xml { head :conflict }
+        end
+      end
+
+      def render_error_page_with_session(status)
+        render :template => "errors/error_with_session", :status => status
+      end
+
+      def render_error_page(status)
+        render :template => "errors/error", :status => status
+      end
+
+      def render_stale_error_page
+        render :template => "errors/stale", :status => :conflict
+      end
+
+      private
+
+      if defined? ::Ixtlan::Audit
+        def user_logger
+          @user_logger ||= Ixtlan::UserLogger.new(Ixtlan::Core::ErrorHandling)
+        end
+        def log_user_error(exception)
+          user_logger.log_action(self, " - #{exception.class} - #{exception.message}")
+          log_error(exception)
+        end
+      else
+        alias :log_user_error :log_error
+      end
+
+      def error_page(status, exception, &block)
+        respond_to do |format|
+          format.html {
+            @notice = block.call(exception)
+            if logged_in?
+              render_error_page_with_session(status)
+            else
+              render_error_page(status)
+            end
+          }
+          format.xml { head status }
+        end
+      end
+
+      def dump_error(exception)
+        log_user_error(exception)
+        dumper = Rails.configuration.error_dumper
+        dumper.dump(self, exception)
+      end
+    end
+  end
+end

data/lib/ixtlan/errors/mailer.rb

@@ -2,9 +2,9 @@ module Ixtlan
   module Errors
     class Mailer < ActionMailer::Base
       
-      def error_notification(email_from, emails_to, exception, error_file)
+      def error_notification(email_from, emails_to, exception, error_url)
         @subject    = exception.message
-        @text       = "#{error_file}"
+        @text       = "#{error_url}"
         @recipients = emails_to
         @from       = email_from
         @sent_on    = Time.now

data/lib/ixtlan/errors/mailer.rb~

@@ -0,0 +1,19 @@
+module Ixtlan
+  module Errors
+    class Mailer < ActionMailer::Base
+
+      path = File.join(File.dirname(__FILE__), "mailer")
+      view_paths << path unless view_paths.member? path
+      
+      
+      def error_notification(email_from, emails_to, exception, error_file)
+        @subject    = exception.message
+        @body       = {:text => "#{error_file}"}
+        @recipients = emails_to
+        @from       = email_from
+        @sent_on    = Time.now
+        @headers    = {}
+      end
+    end
+  end
+end

data/lib/ixtlan/errors/railtie.rb

@@ -14,11 +14,8 @@ module Ixtlan
           ActionMailer::Base.view_paths= [ActionMailer::Base.view_paths, path].flatten 
         end
 
-        app.config.class.class_eval do
-          attr_accessor :error_dumper, :skip_rescue_module
-          app.config.error_dumper = ErrorDumper.new
-          app.config.skip_rescue_module = false
-        end
+        app.config.error_dumper = ErrorDumper.new
+        app.config.skip_rescue_module = false
       end
       
       config.after_initialize do |app|

data/lib/ixtlan/errors/railtie.rb~

@@ -0,0 +1,20 @@
+require 'rails'
+
+module Ixtlan
+  module Errors
+    class Railtie < Rails::Railtie
+
+      config.before_configuration do |app|
+        app.config.class.class_eval do
+          attr_accessor :error_dumper
+          app.config.error_dumper = Ixtlan::Errors::ErrorDumper.new
+        end
+      end
+      
+      config.after_initialization do |app|
+        ::ActionController::Base.send(:include, Ixtlan::Errors::RescueModule)
+        ::ActionController::Base.send(:include, Ixtlan::Errors::ErrorHandler)
+      end
+    end
+  end
+end

data/lib/ixtlan/errors/rescue_module.rb~

@@ -0,0 +1,41 @@
+module Ixtlan
+  module Errors
+    module RescueModule
+      def self.included(controller)
+         if defined? ::Ixtlan::ModifiedBy
+           # needs 'optimistic_persistence'
+           controller.rescue_from ::Ixtlan::ModifiedBy::StaleResourceError, :with => :stale_resource
+         end
+
+        if defined? ::Ixtlan::Guard
+          # needs 'guard'
+          controller.rescue_from ::Ixtlan::Guard::GuardException, :with => :page_not_found
+          controller.rescue_from ::Ixtlan::Guard::PermissionDenied, :with => :page_not_found
+        end
+        
+        if defined? ::DataMapper
+          # datamapper
+          controller.rescue_from ::DataMapper::ObjectNotFoundError, :with => :page_not_found
+        end
+
+        if defined? ::ActiveRecord
+          # activerecord
+          controller.rescue_from ::ActiveRecord::RecordNotFound, :with => :page_not_found
+        end
+
+        # standard rails controller
+        controller.rescue_from ::ActionController::RoutingError, :with => :page_not_found
+        controller.rescue_from ::ActionController::UnknownAction, :with => :page_not_found
+        controller.rescue_from ::ActionController::MethodNotAllowed, :with => :page_not_found
+        controller.rescue_from ::ActionController::NotImplemented, :with => :page_not_found
+        controller.rescue_from ::ActionController::InvalidAuthenticityToken, :with => :stale_resource
+        
+        # have nice stacktraces in development mode
+        unless controller.consider_all_requests_local
+          controller.rescue_from ::ActionView::MissingTemplate, :with => :internal_server_error
+          controller.rescue_from ::ActionView::TemplateError, :with => :internal_server_error
+        end
+      end
+    end
+  end
+end

data/spec/error_dumper_spec.rb

@@ -1,3 +1,27 @@
+require 'dm-core'
+require 'dm-migrations'
+require 'slf4r/ruby_logger'
+
+class Error
+  include DataMapper::Resource
+
+  property :id, Serial
+
+  property :message, String
+  property :clazz, String
+  property :request, Text
+  property :response, Text
+  property :session, Text
+  property :parameters, Text
+  property :backtrace, Text
+
+  property :created_at, DateTime
+
+  before :save do
+    self.created_at = DateTime.now
+  end
+end
+
 module Ixtlan
   module Errors
     module ActionMailer
@@ -62,8 +86,11 @@ class String
 end
 
 class Fixnum
+  def days
+    self
+  end
   def ago
-    DateTime.now - self.to_i
+    DateTime.now - 86000 * self
   end
 end
 
@@ -76,37 +103,44 @@ class DateTime
   end
 end
 
+DataMapper.setup(:default, "sqlite3::memory:")
+DataMapper.finalize
+DataMapper.repository.auto_migrate!
+
 describe Ixtlan::Errors::ErrorDumper do
 
   before :each do
     @dumper = Ixtlan::Errors::ErrorDumper.new
-    @dumper.dump_dir = "target"
+    @dumper.base_url = "http://localhost"
     @controller = Controller.new
   end
 
   it "should dump env and not send notification" do
-    file = @dumper.dump(@controller, StandardError.new("dump it"))
-    File.exists?(file).should be_true
-    @dumper.email_from = "asd"
-    file = @dumper.dump(@controller, StandardError.new("dump it"))
-    File.exists?(file).should be_true
-    @dumper.email_from = nil
-    @dumper.email_to = "dsa"
-    file = @dumper.dump(@controller, StandardError.new("dump it"))
-    File.exists?(file).should be_true
+    url = @dumper.dump(@controller, StandardError.new("dump it"))
+    url.should =~ /http:\/\/localhost\/[0-9]+/
+    @dumper.from_email = "asd"
+    url = @dumper.dump(@controller, StandardError.new("dump it"))
+    url.should =~ /http:\/\/localhost\/[0-9]+/
+    @dumper.from_email = nil
+    @dumper.to_emails = "dsa"
+    url = @dumper.dump(@controller, StandardError.new("dump it"))
+    url.should =~ /http:\/\/localhost\/[0-9]+/
   end
 
   it "should clean up error dumps" do
+    Error.create(:message => 'msg')
+    Error.all.size.should > 0
     @dumper.keep_dumps = 0
+    Error.all.size.should == 0
     @dumper.dump(@controller, StandardError.new("dump it"))
-    Dir['target/error-*'].size.should == 1
+    Error.all.size.should == 1
     @dumper.dump(@controller, StandardError.new("dump it"))
-    Dir['target/error-*'].size.should == 1
+    Error.all.size.should == 2
   end
 
   it "should send notifications" do
-    @dumper.email_to = "das"
-    @dumper.email_from = "asd"
+    @dumper.to_emails = "das"
+    @dumper.from_email = "asd"
     @dumper.dump(@controller, StandardError.new("dump it"))
     Ixtlan::Errors::ActionMailer::Base.delivered.should be_true
   end

data/spec/error_dumper_spec.rb~

@@ -0,0 +1,8 @@
+require 'ixtlan/errors/error_dumper'
+
+
+describe Ixtlan::Errors::ErrorDumper do
+
+
+
+end

data/spec/error_handler_spec.rb~

@@ -0,0 +1,60 @@
+require 'ixtlan/errors/error_dumper'
+require 'date'
+require 'logger'
+
+class Controller
+
+  def request
+    self
+  end
+  def env
+    @env ||= {:one => 1, :two => 2, :three => 3}
+  end
+
+  def response
+    self
+  end
+
+  def headers
+    @headers ||= { 'ONE' => 1, "TWO" => 2 }
+  end
+
+  def session
+    @session ||= { "user" => "me" }
+  end
+
+  def params
+    @params ||= { :query => "all" }
+  end
+end
+
+class NilClass
+  def blank?
+    true
+  end
+end
+
+class String
+  def blank?
+    size == 0
+  end
+end
+
+class Fixnum
+  def ago
+    DateTime.now - self.to_i
+  end
+end
+
+# class DateTime
+#   def tv_sec
+#     sec
+#   end
+#   def tv_usec
+#     0
+#   end
+# end
+
+describe Ixtlan::Errors::ErrorHandler do
+
+end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: ixtlan-error-handler
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-    - 0
-    - 1
-    - 1
-  version: 0.1.1
+  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors: 
   - mkristian
@@ -14,51 +10,75 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-22 00:00:00 +05:30
+date: 2011-11-04 00:00:00 +05:30
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
-    name: rspec
+    name: slf4r
     prerelease: false
     requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
       requirements: 
-        - - "="
+        - - ~>
           - !ruby/object:Gem::Version 
-            segments: 
-              - 2
-              - 4
-              - 0
-            version: 2.4.0
-    type: :development
+            version: 0.4.2
+    type: :runtime
     version_requirements: *id001
   - !ruby/object:Gem::Dependency 
-    name: rake
+    name: rspec
     prerelease: false
     requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
       requirements: 
         - - "="
           - !ruby/object:Gem::Version 
-            segments: 
-              - 0
-              - 8
-              - 7
-            version: 0.8.7
+            version: 2.6.0
     type: :development
     version_requirements: *id002
   - !ruby/object:Gem::Dependency 
-    name: cucumber
+    name: rake
     prerelease: false
     requirement: &id003 !ruby/object:Gem::Requirement 
+      none: false
       requirements: 
-        - - ">="
+        - - "="
           - !ruby/object:Gem::Version 
-            segments: 
-              - 0
-              - 0
-              - 0
-            version: 0.0.0
+            version: 0.8.7
     type: :development
     version_requirements: *id003
+  - !ruby/object:Gem::Dependency 
+    name: dm-core
+    prerelease: false
+    requirement: &id004 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - "="
+          - !ruby/object:Gem::Version 
+            version: 1.2.0
+    type: :development
+    version_requirements: *id004
+  - !ruby/object:Gem::Dependency 
+    name: dm-migrations
+    prerelease: false
+    requirement: &id005 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - "="
+          - !ruby/object:Gem::Version 
+            version: 1.2.0
+    type: :development
+    version_requirements: *id005
+  - !ruby/object:Gem::Dependency 
+    name: dm-sqlite-adapter
+    prerelease: false
+    requirement: &id006 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - "="
+          - !ruby/object:Gem::Version 
+            version: 1.2.0
+    type: :development
+    version_requirements: *id006
 description: dump errors on filesystem and notify developers, map different errors to specific pages
 email: 
   - m.kristian@web.de
@@ -69,15 +89,25 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+  - MIT-LICENSE
+  - README.textile
   - lib/ixtlan-error-handler.rb
-  - lib/ixtlan/errors/railtie.rb
-  - lib/ixtlan/errors/error_handler.rb
+  - lib/ixtlan/errors/error_dumper.rb
   - lib/ixtlan/errors/mailer.rb
+  - lib/ixtlan/errors/error_handling.rb~
+  - lib/ixtlan/errors/rescue_module.rb~
   - lib/ixtlan/errors/rescue_module.rb
-  - lib/ixtlan/errors/error_dumper.rb
+  - lib/ixtlan/errors/error_dumper.rb~
+  - lib/ixtlan/errors/error_handler.rb~
+  - lib/ixtlan/errors/railtie.rb~
+  - lib/ixtlan/errors/error_handler.rb
+  - lib/ixtlan/errors/railtie.rb
+  - lib/ixtlan/errors/mailer.rb~
   - lib/ixtlan/errors/mailer/error_notification.erb
-  - spec/error_dumper_spec.rb
   - spec/error_handler_spec.rb
+  - spec/error_dumper_spec.rb~
+  - spec/error_handler_spec.rb~
+  - spec/error_dumper_spec.rb
 has_rdoc: true
 homepage: http://github.com/mkristian/ixtlan-error-handler
 licenses: 
@@ -89,26 +119,24 @@ rdoc_options:
 require_paths: 
   - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-          - 0
         version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-          - 0
         version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.5.1
 signing_key: 
 specification_version: 3
 summary: dump errors on filesystem and notify developers
 test_files: 
-  - spec/error_dumper_spec.rb
   - spec/error_handler_spec.rb
+  - spec/error_dumper_spec.rb