simonmenke-exception_browser_plugin_for_rails 0.0.1

data/Rakefile

@@ -0,0 +1,5 @@
+task :build do
+  sh "gem build exception_browser_plugin_for_rails.gemspec"
+end
+
+task :default => :build

data/lib/exception_browser_plugin_for_rails.rb

@@ -0,0 +1,11 @@
+require "exception_browser_plugin_for_rails/version"
+require 'exception_browser_plugin_for_rails/controller_extensions'
+
+module ExceptionBrowser
+  @@gateway = nil
+  @@reporter_token = nil
+  @@only_in_public = true
+  mattr_accessor :gateway, :reporter_token, :only_in_public
+end
+
+ActionController::Base.send :include, ExceptionBrowser::Plugin

data/lib/exception_browser_plugin_for_rails/controller_extensions.rb

@@ -0,0 +1,138 @@
+
+module ExceptionBrowser
+  module Plugin
+    def self.included(target)
+      target.send(:extend,  ExceptionBrowser::Plugin::ClassMethods)
+    end
+    
+    def rescue_action_in_public(exception)
+      status = response_code_for_rescue(exception)
+      render_optional_error_file status
+      log_exception(exception) if status != :not_found
+    end
+    
+    def rescue_action_locally(exception)
+      add_variables_to_assigns
+      @template.instance_variable_set("@exception", exception)
+      @template.instance_variable_set("@rescues_path", File.dirname(rescues_path("stub")))
+      @template.send!(:assign_variables_from_controller)
+      
+      @template.instance_variable_set("@contents", @template.render_file(template_path_for_local_rescue(exception), false))
+      
+      response.content_type = Mime::HTML
+      
+      status = response_code_for_rescue(exception)
+      render_for_file(rescues_path("layout"), status)
+      log_exception(exception) if status != :not_found and !ExceptionBrowser.only_in_public
+    end
+    
+    module ClassMethods
+  
+      def exception_data(deliverer = self, &block)
+        deliverer = block if block
+        if deliverer == self
+          read_inheritable_attribute(:exception_data)
+        else
+          write_inheritable_attribute(:exception_data, deliverer)
+        end
+      end
+      
+      def clean_backtrace_regex
+        if @clean_backtrace_regex.nil?
+          rails_path_prefixes= Pathname.new(RAILS_ROOT).cleanpath.to_s
+          
+          paths = `gem environment gempath`.strip.split(":")
+          gems_path_prefixes = paths.collect { |path| Pathname.new(path+"/gems").cleanpath.to_s }
+          
+          paths = `ruby -e 'puts $:.reject{|p|p=="."}.join(":")'`.strip.split(":")
+          system_path_prefixes = paths.collect { |path| Pathname.new(path).cleanpath.to_s }
+          
+          @clean_backtrace_regex = { 
+            :rails  => /^(#{Regexp.escape(rails_path_prefixes)})/,
+            :gems   => /^(#{gems_path_prefixes.collect{|path|Regexp.escape(path)}.join('|')})/,
+            :system => /^(#{system_path_prefixes.collect{|path|Regexp.escape(path)}.join('|')})/
+          }
+        end
+        @clean_backtrace_regex
+      end
+      
+      def sanitaize_backtrace_entry(line)
+        line = line.strip
+        line.gsub!('in `', "")
+        line.gsub!("'", "")
+        line.gsub!(clean_backtrace_regex[:rails],  "[RAILS_ROOT]")
+        line.gsub!(clean_backtrace_regex[:gems],   "[GEM]")
+        line.gsub!(clean_backtrace_regex[:system], "[SYSTEM]")
+        Pathname.new(line).cleanpath.to_s
+      end
+      
+    end
+    
+    def exception_data(exception)
+      deliverer = self.class.exception_data
+      data = case deliverer
+        when nil    then {}
+        when Symbol then send(deliverer)
+        when Proc   then deliverer.call(self)
+      end
+      
+      { :exception => {
+        :class_name      => exception.class.name,
+        :controller_name => controller_name,
+        :action_name     => action_name,
+        :message         => exception.message,
+        :extra_message   => data,
+        :guid            => Digest::SHA1.hexdigest(Time.new.to_f.to_s + "." + (rand(8999)+1000).to_s).upcase,
+        :raised_at       => Time.new,
+        :environment     => environment_data(exception),
+        :request => {
+          :protocol      => request.protocol,
+          :host          => request.env["HTTP_HOST"],
+          :uri           => request.request_uri,
+          :method        => request.method.to_s,
+          :format        => request.format.to_s,
+          :parameters    => request.parameters.to_hash,
+          :rails_root    => Pathname.new(RAILS_ROOT).cleanpath.to_s
+        },
+        :backtrace       => backtrace_data(exception.backtrace)
+      } }.to_xml.sub(/^<hash>/, "").sub(/<\/hash>$/, "")
+    end
+    
+    def backtrace_data(raw_lines)
+      raw_lines = raw_lines.collect { |string| string.split("\n") }.flatten.collect(&:strip)
+      raw_lines = raw_lines.reject  { |string| string.blank? or (string =~ /^(On line|\d+\:)/) }
+      return      raw_lines.collect { |raw_line| backtrace_entry_data(raw_line) }
+    end
+    
+    def backtrace_entry_data(raw_line)
+      raw_line = self.class.sanitaize_backtrace_entry(raw_line).split(':')
+      data = { :file => raw_line.shift,
+               :line => raw_line.shift.to_i }
+      data[:method] = raw_line.shift unless raw_line.empty?
+      data
+    end
+    
+    def environment_data(exception)
+      data = {
+        "PROCESS" => $$,
+        "SERVER"  => `hostname -s`.chomp }
+      self.request.env.each { |k,v| data[k] = v }
+      data
+    end
+    
+    def log_exception(exception)
+      return if ExceptionBrowser.gateway.blank? or ExceptionBrowser.reporter_token.blank?
+      
+      url = URI.parse(ExceptionBrowser.gateway)
+      
+      req = Net::HTTP::Post.new(url.path)
+      req.set_content_type "text/xml"
+      req.basic_auth ExceptionBrowser.reporter_token, 'x'
+      req.body = exception_data(exception)
+      
+      res = Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }
+      res.error! unless res.is_a? Net::HTTPSuccess
+    end
+    
+  end
+end

data/lib/exception_browser_plugin_for_rails/version.rb

@@ -0,0 +1,10 @@
+
+module ExceptionBrowser
+  module Version
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+    
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: simonmenke-exception_browser_plugin_for_rails
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Simon Menke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-12 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Allows Rails to forward exceptions to exception_browser
+email: 
+- simon@5xm.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- License.txt
+files: 
+- History.txt
+- License.txt
+- README.markdown
+- Rakefile
+- lib/exception_browser_plugin_for_rails.rb
+- lib/exception_browser_plugin_for_rails/controller_extensions.rb
+- lib/exception_browser_plugin_for_rails/version.rb
+has_rdoc: true
+homepage: http://github.com/simonmenke/exception_browser_plugin_for_rails
+post_install_message: 
+rdoc_options: 
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Allows Rails to forward exceptions to exception_browser
+test_files: []
+