failtale-reporter 0.2.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Mr.Henry
+
+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.md

@@ -0,0 +1 @@
+# Failtale Reporter

data/lib/failtale-reporter.rb

@@ -0,0 +1 @@
+require File.expand_path('../failtale_reporter', __FILE__)

data/lib/failtale_reporter.rb

@@ -0,0 +1,60 @@
+module FailtaleReporter
+
+  require 'digest/sha1'
+  require 'httparty'
+
+  require 'failtale_reporter/version'
+  require 'failtale_reporter/error'
+  require 'failtale_reporter/client'
+  require 'failtale_reporter/configuration'
+  require 'failtale_reporter/backtrace_cleaner'
+  require 'failtale_reporter/information_collector'
+  require 'failtale_reporter/adapters'
+
+
+  include HTTParty
+  extend FailtaleReporter::Adapters
+  extend FailtaleReporter::Configuration
+  extend FailtaleReporter::BacktraceCleaner
+  extend FailtaleReporter::InformationCollector
+
+  base_uri 'failtale.be'
+  format :xml
+
+  default_reporter 'ruby'
+
+  backtrace_cleaner do |line|
+    if FailtaleReporter.application_root
+      line.sub! FailtaleReporter.application_root, "[APP]"
+    end
+  end
+
+  if defined?(Gem)
+    class << self
+      def gem_backtrace_cleaner(spec)
+        @gem_backtrace_cleaner ||= {}
+        unless @gem_backtrace_cleaner[spec.full_name]
+          @gem_backtrace_cleaner[spec.full_name] = {
+            :regexp => backtrace_cleaner_regexp(spec.full_gem_path),
+            :label  => "[GEM: #{spec.name} @#{spec.version.to_s}]"
+          }
+        end
+        @gem_backtrace_cleaner[spec.full_name]
+      end
+    end
+    backtrace_cleaner do |line|
+      cleaned_line = nil
+      Gem.loaded_specs.values.each do |spec|
+        options = FailtaleReporter.gem_backtrace_cleaner(spec)
+        cleaned_line = line.sub!(options[:regexp], options[:label])
+        break if cleaned_line
+      end
+      cleaned_line
+    end
+  end
+
+  def self.report(error=nil, *ctxs, &block)
+    Client.new.report(error, *ctxs, &block)
+  end
+
+end

data/lib/failtale_reporter/adapters.rb

@@ -0,0 +1,7 @@
+module FailtaleReporter::Adapters
+
+  def self.load_adapter(name)
+    require "failtale_reporter/adapters/#{name}"
+  end
+
+end

data/lib/failtale_reporter/adapters/rails.rb

@@ -0,0 +1,51 @@
+
+module FailtaleReporter
+  module Adapters
+    
+    module Rails
+      
+      IGNORED_EXCEPTIONS = ['ActiveRecord::RecordNotFound',
+                            'ActionController::RoutingError',
+                            'ActionController::InvalidAuthenticityToken',
+                            'CGI::Session::CookieStore::TamperedWithCookie']
+      
+      IGNORED_EXCEPTIONS.map!{|e| eval(e) rescue nil }.compact!
+      IGNORED_EXCEPTIONS.freeze
+      
+      def self.included(target)
+        target.send :alias_method_chain, :rescue_action_in_public, :failtale
+        
+        FailtaleReporter.configure do |config|
+          config.ignored_exceptions IGNORED_EXCEPTIONS
+          config.default_reporter "rails"
+          config.application_root RAILS_ROOT
+          config.information_collector do |error, controller|
+            env = error.environment
+            env = env.merge(controller.request.env)
+            
+            env.delete('action_controller.rescue.response')
+            env.delete('action_controller.rescue.request')
+            error.environment = env
+          end
+        end
+      end
+      
+      def rescue_action_in_public_with_failtale(exception)
+        FailtaleReporter.report(exception, self) unless is_private?
+        rescue_action_in_public_without_failtale(exception)
+      end
+      
+      protected
+      
+      def is_private? #nodoc:
+        if defined?(RAILS_ENV)
+          ['development', 'test'].include?(RAILS_ENV)
+        end
+      end
+      
+    end
+    
+  end
+end
+
+::ActionController::Base.send :include, FailtaleReporter::Adapters::Rails

data/lib/failtale_reporter/backtrace_cleaner.rb

@@ -0,0 +1,32 @@
+module FailtaleReporter::BacktraceCleaner
+
+  def clean_backtrace(backtrace)
+    backtrace.collect do |line|
+      path = File.expand_path(line.split(':').first)
+      if File.exist?(path)
+        line = File.expand_path(line)
+        cleaned_line = nil
+        backtrace_cleaners.each do |proc|
+          cleaned_line = proc.call(line)
+          break if cleaned_line
+        end
+        cleaned_line || line
+      else
+        line
+      end
+    end
+  end
+
+  def backtrace_cleaners
+    @backtrace_cleaners ||= []
+  end
+
+  def backtrace_cleaner(&block)
+    backtrace_cleaners.push(block)
+  end
+
+  def backtrace_cleaner_regexp(path)
+    Regexp.new("^#{Regexp.escape(File.expand_path(path))}")
+  end
+
+end

data/lib/failtale_reporter/client.rb

@@ -0,0 +1,30 @@
+class FailtaleReporter::Client
+
+  def report(error=nil, *ctxs)
+    error = handle_exception(error, ctxs)
+    yield if block_given? and error.nil?
+  rescue Exception => exception
+    error = handle_exception(exception, ctxs)
+  ensure
+    post_report(error) unless error.nil?
+    raise exception unless exception.nil?
+  end
+
+private
+
+  def handle_exception(exception, ctxs)
+    return exception if exception.is_a? FailtaleReporter::Error
+    return nil if     exception.nil?
+    return nil unless FailtaleReporter.reportable_exceptions.any? {|c| exception.is_a? c }
+    return nil if     FailtaleReporter.ignored_exceptions.any?    {|c| exception.is_a? c }
+    FailtaleReporter::Error.new(exception, ctxs)
+  rescue Exception => e
+    puts "#{e.class}: #{e.message}"
+    puts e.backtrace
+  end
+
+  def post_report(error)
+    response = FailtaleReporter.post('/reports.xml', :body => error.to_param)
+  end
+
+end

data/lib/failtale_reporter/configuration.rb

@@ -0,0 +1,30 @@
+module FailtaleReporter::Configuration
+
+  def reportable_exceptions(*arr)
+    arr = [Exception] if (arr || []).empty?
+    @reportable_exceptions ||= arr.flatten
+  end
+
+  def ignored_exceptions(*arr)
+    @ignored_exceptions ||= arr.flatten
+  end
+
+  def api_token(token=nil)
+    @api_token ||= token
+  end
+
+  def default_reporter(reporter=nil)
+    @default_reporter = reporter if reporter
+    @default_reporter
+  end
+
+  def application_root(path=nil)
+    @application_root = backtrace_cleaner_regexp(path) if path
+    @application_root
+  end
+
+  def configure
+    yield self
+  end
+
+end

data/lib/failtale_reporter/error.rb

@@ -0,0 +1,50 @@
+class FailtaleReporter::Error
+
+  attr_accessor :api_token
+  attr_accessor :hash_string
+  attr_accessor :name
+  attr_accessor :reporter
+  attr_accessor :description
+  attr_accessor :properties
+  attr_accessor :backtrace
+  attr_accessor :environment
+
+  def initialize(exception, ctxs=[])
+    self.api_token = FailtaleReporter.api_token
+    self.reporter  = FailtaleReporter.default_reporter
+
+    self.name = "#{exception.class} #{exception.message}"
+    self.description = exception.message
+    self.backtrace = FailtaleReporter.clean_backtrace(exception.backtrace).join("\n")
+    self.environment = ENV.to_hash
+    self.hash_string = Digest::SHA1.hexdigest(
+      [exception.class, exception.backtrace.first].join('--')
+    )
+    FailtaleReporter.collect_information(self, ctxs)
+
+    self.backtrace = self.backtrace.inspect unless self.backtrace.is_a? String
+    self.environment = self.environment.inject({}) do |m,(k,v)|
+      k = k.inspect unless k.is_a? String
+      v = v.inspect unless v.is_a? String
+      m[k] = v
+      m
+    end
+  end
+
+  def to_param
+    { :report =>
+      { :project => {
+        :api_token => self.api_token
+      },:error => {
+        :hash_string => self.hash_string
+      },:occurence => {
+        :name => self.name,
+        :reporter => self.reporter,
+        :description => self.description,
+        :backtrace => self.backtrace,
+        :properties => self.environment
+      } }
+    }
+  end
+
+end

data/lib/failtale_reporter/information_collector.rb

@@ -0,0 +1,17 @@
+module FailtaleReporter::InformationCollector
+
+  def collect_information(error, ctxs)
+    information_collectors.each do |proc|
+      proc.call(error, *ctxs)
+    end
+  end
+
+  def information_collectors
+    @information_collectors ||= []
+  end
+
+  def information_collector(&block)
+    information_collectors.push(block)
+  end
+
+end

data/lib/failtale_reporter/version.rb

@@ -0,0 +1,3 @@
+module FailtaleReporter
+  VERSION = "0.2.0"
+end

data/rails/init.rb

@@ -0,0 +1,2 @@
+
+::FailtaleReporter.load_adapter('rails')

data/spec/error_reporter_spec.rb

@@ -0,0 +1,33 @@
+
+describe "ErrorReporter" do
+  
+  it "should send error reports" do
+    ErrorReporter.should_receive(:post).with('/reports.xml', an_instance_of(Hash))
+    lambda do
+      ErrorReporter.report do
+        raise "hello"
+      end
+    end.should raise_error(RuntimeError, "hello")
+  end
+  
+  it "should send error reports for selected exceptions" do
+    ErrorReporter.should_receive(:post).with('/reports.xml', an_instance_of(Hash))
+    ErrorReporter.reportable_exceptions ArgumentError
+    lambda do
+      ErrorReporter.report do
+        raise ArgumentError, "hello"
+      end
+    end.should raise_error(ArgumentError, "hello")
+  end
+  
+  it "should not send error reports for non-selected exceptions" do
+    ErrorReporter.should_not_receive(:post)
+    ErrorReporter.reportable_exceptions ArgumentError
+    lambda do
+      ErrorReporter.report do
+        raise RuntimeError, "hello"
+      end
+    end.should raise_error(RuntimeError, "hello")
+  end
+  
+end

data/spec/error_spec.rb

@@ -0,0 +1,22 @@
+
+require File.dirname(__FILE__)+'/../lib/failtale_reporter'
+
+describe "ErrorReporter::Error" do
+  
+  describe "#to_param" do
+    
+    it "should generate valid data" do
+      begin
+        raise "hello"
+      rescue Exception => exception
+        error = ErrorReporter::Error.new(exception)
+        
+        error.backtrace.should   be_eql(exception.backtrace.join("\n"))
+        error.description.should be_eql(exception.message)
+        error.name.should        be_eql("#{exception.class} raised at #{exception.backtrace.first}")
+      end
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: failtale-reporter
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Simon Menke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-20 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: httparty
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: A Ruby error reporter for the Failtale service
+email: 
+- simon.menke@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/failtale-reporter.rb
+- lib/failtale_reporter/adapters/rails.rb
+- lib/failtale_reporter/adapters.rb
+- lib/failtale_reporter/backtrace_cleaner.rb
+- lib/failtale_reporter/client.rb
+- lib/failtale_reporter/configuration.rb
+- lib/failtale_reporter/error.rb
+- lib/failtale_reporter/information_collector.rb
+- lib/failtale_reporter/version.rb
+- lib/failtale_reporter.rb
+- rails/init.rb
+- spec/error_reporter_spec.rb
+- spec/error_spec.rb
+- LICENSE
+- README.md
+has_rdoc: true
+homepage: http://github.com/mrhenry
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: failtale_reporter
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A ruby reporter for Failtale
+test_files: []
+