lichtamberg-Lighthouse_Exception_Logger 0.0.1

data/README.txt

@@ -0,0 +1,50 @@
+THIS GEM IS IN PROGRESS - ITS NOT WORKING AT THE MOMENT!
+
+= LighthouseExe
+
+* FIX (url)
+
+== DESCRIPTION:
+
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 FIX
+
+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/lib/LighthouseExceptionLogger.rb

@@ -0,0 +1,252 @@
+require 'net/http'
+require 'net/https'
+require 'rubygems'
+require 'active_support'
+require 'lighthouse'
+
+# Plugin for applications to automatically post errors to the Hoptoad of their choice.
+module LighthouseExceptionLogger
+
+  VERSION = '0.0.1'
+  IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
+                    'ActionController::RoutingError',
+                    'ActionController::InvalidAuthenticityToken',
+                    'CGI::Session::CookieStore::TamperedWithCookie']
+
+  # Some of these don't exist for Rails 1.2.*, so we have to consider that.
+  IGNORE_DEFAULT.map!{|e| eval(e) rescue nil }.compact!
+  IGNORE_DEFAULT.freeze
+
+  class << self
+    attr_accessor :host, :port, :secure, :api_key
+    attr_reader :backtrace_filters
+
+    # Takes a block and adds it to the list of backtrace filters. When the filters
+    # run, the block will be handed each line of the backtrace and can modify
+    # it as necessary. For example, by default a path matching the RAILS_ROOT
+    # constant will be transformed into "[RAILS_ROOT]"
+    def filter_backtrace &block
+      (@backtrace_filters ||= []) << block
+    end
+
+    # Returns the list of errors that are being ignored. The array can be appended to.
+    def ignore
+      @ignore ||= (LighthouseExceptionLogger::IGNORE_DEFAULT.dup)
+      @ignore.flatten!
+      @ignore
+    end
+
+    # Sets the list of ignored errors to only what is passed in here. This method
+    # can be passed a single error or a list of errors.
+    def ignore_only=(names)
+      @ignore = [names].flatten
+    end
+
+    # Returns a list of parameters that should be filtered out of what is sent to Lighthouse.
+    # By default, all "password" attributes will have their contents replaced.
+    def params_filters
+      @params_filters ||= %w(password)
+    end
+
+    def environment_filters
+      @environment_filters ||= %w()
+    end
+
+    # You can send an exception manually using this method, even when you are not in a
+    # controller. You can pass an exception or a hash that contains the attributes that
+    # would be sent to Hoptoad:
+    # * api_key: The API key for this project. The API key is a unique identifier that Hoptoad
+    # uses for identification.
+    # * error_message: The error returned by the exception (or the message you want to log).
+    # * backtrace: A backtrace, usually obtained with +caller+.
+    # * request: The controller's request object.
+    # * session: The contents of the user's session.
+    # * environment: ENV merged with the contents of the request's environment.
+    def notify notice = {}
+      Sender.new.notify_lighthouse( notice )
+    end
+  end
+
+  filter_backtrace do |line|
+    line.gsub(/#{RAILS_ROOT}/, "[RAILS_ROOT]")
+  end
+
+  filter_backtrace do |line|
+    line.gsub(/^\.\//, "")
+  end
+
+  filter_backtrace do |line|
+    if defined?(Gem)
+      Gem.path.inject(line) do |line, path|
+        line.gsub(/#{path}/, "[GEM_ROOT]")
+      end
+    end
+  end
+
+  # Include this module in Controllers in which you want to be notified of errors.
+  module Catcher
+
+    def self.included(base) #:nodoc:
+      if base.instance_methods.include? 'rescue_action_in_public' and !base.instance_methods.include? 'rescue_action_in_public_without_LighthouseExceptionLogger'
+        base.send(:alias_method, :rescue_action_in_public_without_LighthouseExceptionLogger, :rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_LighthouseExceptionLogger)
+      end
+    end
+
+    # Overrides the rescue_action method in ActionController::Base, but does not inhibit
+    # any custom processing that is defined with Rails 2's exception helpers.
+    def rescue_action_in_public_with_LighthouseExceptionLogger exception
+      notify_lighthouse(exception) unless ignore?(exception)
+      rescue_action_in_public_without_LighthouseExceptionLogger(exception)
+    end
+
+    # This method should be used for sending manual notifications while you are still
+    # inside the controller. Otherwise it works like LighthouseExceptionLogger.notify.
+    def notify_lighthouse hash_or_exception
+      if public_environment?
+        notice = normalize_notice(hash_or_exception)
+        notice = clean_notice(notice)
+        send_to_LighthouseExceptionLogger(:notice => notice)
+      end
+    end
+
+    alias_method :inform_lighthouse, :notify_lighthouse
+
+    # Returns the default logger or a logger that prints to STDOUT. Necessary for manual
+    # notifications outside of controllers.
+    def logger
+      ActiveRecord::Base.logger
+    rescue
+      @logger ||= Logger.new(STDERR)
+    end
+
+    private
+
+    def public_environment? #nodoc:
+      defined?(RAILS_ENV) and !['development', 'test'].include?(RAILS_ENV)
+    end
+
+    def ignore?(exception) #:nodoc:
+      ignore_these = LighthouseExceptionLogger.ignore.flatten
+      ignore_these.include?(exception.class) || ignore_these.include?(exception.class.name)
+    end
+
+    def exception_to_data exception #:nodoc:
+      data = {
+        :error_class => exception.class.name,
+        :error_message => "#{exception.class.name}: #{exception.message}",
+        :backtrace => exception.backtrace,
+        :environment => ENV.to_hash
+      }
+
+      if self.respond_to? :request
+        data[:request] = {
+          :params => request.parameters.to_hash,
+          :rails_root => File.expand_path(RAILS_ROOT),
+          :url => "#{request.protocol}#{request.host}#{request.request_uri}"
+        }
+        data[:environment].merge!(request.env.to_hash)
+      end
+
+      if self.respond_to? :session
+        data[:session] = {
+          :key => session.instance_variable_get("@session_id"),
+          :data => session.instance_variable_get("@data")
+        }
+      end
+
+      data
+    end
+
+    def normalize_notice(notice) #:nodoc:
+      case notice
+      when Hash
+        LighthouseExceptionLogger.default_notice_options.merge(notice)
+      when Exception
+        LighthouseExceptionLogger.default_notice_options.merge(exception_to_data(notice))
+      end
+    end
+
+    def clean_notice(notice) #:nodoc:
+      notice[:backtrace] = clean_LighthouseExceptionLogger_backtrace(notice[:backtrace])
+      if notice[:request].is_a?(Hash) && notice[:request][:params].is_a?(Hash)
+        notice[:request][:params] = filter_parameters(notice[:request][:params]) if respond_to?(:filter_parameters)
+        notice[:request][:params] = clean_LighthouseExceptionLogger_params(notice[:request][:params])
+      end
+      if notice[:environment].is_a?(Hash)
+        notice[:environment] = filter_parameters(notice[:environment]) if respond_to?(:filter_parameters)
+        notice[:environment] = clean_LighthouseExceptionLogger_environment(notice[:environment])
+      end
+      clean_non_serializable_data(notice)
+    end
+
+    def send_to_LighthouseExceptionLogger data #:nodoc:
+      Lighthouse.account = LIGHTHOUSE_ACCOUNT
+      if defined?(LIGHTHOUSE_TOKEN)
+        Lighthouse.token = LIGHTHOUSE_TOKEN
+      else
+       Lighthouse.authenticate(LIGHTHOUSE_USERNAME, LIGHTHOUSE_PASSWORD)
+      end
+      
+      act_project = Project.find(LIGHTHOUSE_PROJETCT_ID)
+      if act_project.tickets.count(:conditions => {["subject like ?", data.hashcode]})
+        act_project.tickets.new(data).save
+      end
+    end
+
+    def clean_LighthouseExceptionLogger_backtrace backtrace #:nodoc:
+      if backtrace.to_a.size == 1
+        backtrace = backtrace.to_a.first.split(/\n\s*/)
+      end
+
+      backtrace.to_a.map do |line|
+        LighthouseExceptionLogger.backtrace_filters.inject(line) do |line, proc|
+          proc.call(line)
+        end
+      end
+    end
+
+    def clean_LighthouseExceptionLogger_params params #:nodoc:
+      params.each do |k, v|
+        params[k] = "[FILTERED]" if LighthouseExceptionLogger.params_filters.any? do |filter|
+          k.to_s.match(/#{filter}/)
+        end
+      end
+    end
+
+    def clean_LighthouseExceptionLogger_environment env #:nodoc:
+      env.each do |k, v|
+        env[k] = "[FILTERED]" if LighthouseExceptionLogger.environment_filters.any? do |filter|
+          k.to_s.match(/#{filter}/)
+        end
+      end
+    end
+
+    def clean_non_serializable_data(notice) #:nodoc:
+      notice.select{|k,v| serialzable?(v) }.inject({}) do |h, pair|
+        h[pair.first] = pair.last.is_a?(Hash) ? clean_non_serializable_data(pair.last) : pair.last
+        h
+      end
+    end
+
+    def serialzable?(value) #:nodoc:
+      !(value.is_a?(Module) || value.kind_of?(IO))
+    end
+
+    def stringify_keys(hash) #:nodoc:
+      hash.inject({}) do |h, pair|
+        h[pair.first.to_s] = pair.last.is_a?(Hash) ? stringify_keys(pair.last) : pair.last
+        h
+      end
+    end
+
+  end
+
+  # A dummy class for sending notifications manually outside of a controller.
+  class Sender
+    def rescue_action_in_public(exception)
+    end
+
+    include LighthouseExceptionLogger::Catcher
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: lichtamberg-Lighthouse_Exception_Logger
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Peter Lampesberger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-25 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: Caged-lighthouse-api
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
+description: Creates exception-tickets in Lighthouse, similar to HopToads-functionality
+email: 
+- lampesberger.peter@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.txt
+- lib/LighthouseExceptionLogger.rb
+has_rdoc: true
+homepage: http://github.com/lichtamberg/lighthouse_exception_logger/tree/master
+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: Lighthouse_Exception_Logger
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Creates exception-tickets in Lighthouse, similar to HopToads-functionality
+test_files: []
+