cloudtrapper 0.0.2.pre

data/lib/cloudtrapper/notice.rb

@@ -0,0 +1,348 @@
+require 'builder'
+require 'socket'
+
+module Cloudtrapper
+  class Notice
+
+    # The exception that caused this notice, if any
+    attr_reader :exception
+
+    # The API key for the project to which this notice should be sent
+    attr_reader :api_key
+
+    # The backtrace from the given exception or hash.
+    attr_reader :backtrace
+
+    # The name of the class of error (such as RuntimeError)
+    attr_reader :error_class
+
+    # The name of the server environment (such as "production")
+    attr_reader :environment_name
+
+    # CGI variables such as HTTP_METHOD
+    attr_reader :cgi_data
+
+    # The message from the exception, or a general description of the error
+    attr_reader :error_message
+
+    # See Configuration#backtrace_filters
+    attr_reader :backtrace_filters
+
+    # See Configuration#params_filters
+    attr_reader :params_filters
+
+    # A hash of parameters from the query string or post body.
+    attr_reader :parameters
+    alias_method :params, :parameters
+
+    # The component (if any) which was used in this request (usually the controller)
+    attr_reader :component
+    alias_method :controller, :component
+
+    # The action (if any) that was called in this request
+    attr_reader :action
+
+    # A hash of session data from the request
+    attr_reader :session_data
+
+    # The path to the project that caused the error (usually Rails.root)
+    attr_reader :project_root
+
+    # The URL at which the error occurred (if any)
+    attr_reader :url
+
+    # See Configuration#ignore
+    attr_reader :ignore
+
+    # See Configuration#ignore_by_filters
+    attr_reader :ignore_by_filters
+
+    # The name of the notifier library sending this notice, such as "Cloudtrapper Notifier"
+    attr_reader :notifier_name
+
+    # The version number of the notifier library sending this notice, such as "2.1.3"
+    attr_reader :notifier_version
+
+    # A URL for more information about the notifier library sending this notice
+    attr_reader :notifier_url
+
+    # The host name where this error occurred (if any)
+    attr_reader :hostname
+
+    def initialize(args)
+      self.args         = args
+      self.exception    = args[:exception]
+      self.api_key      = args[:api_key]
+      self.project_root = args[:project_root]
+      self.url          = args[:url] || rack_env(:url)
+
+      self.notifier_name    = args[:notifier_name]
+      self.notifier_version = args[:notifier_version]
+      self.notifier_url     = args[:notifier_url]
+
+      self.ignore              = args[:ignore]              || []
+      self.ignore_by_filters   = args[:ignore_by_filters]   || []
+      self.backtrace_filters   = args[:backtrace_filters]   || []
+      self.params_filters      = args[:params_filters]      || []
+      self.parameters          = args[:parameters] ||
+                                   action_dispatch_params ||
+                                   rack_env(:params) ||
+                                   {}
+      self.component           = args[:component] || args[:controller] || parameters['controller']
+      self.action              = args[:action] || parameters['action']
+
+      self.environment_name = args[:environment_name]
+      self.cgi_data         = args[:cgi_data] || args[:rack_env]
+      self.backtrace        = Backtrace.parse(exception_attribute(:backtrace, caller), :filters => self.backtrace_filters)
+      self.error_class      = exception_attribute(:error_class) {|exception| exception.class.name }
+      self.error_message    = exception_attribute(:error_message, 'Notification') do |exception|
+        "#{exception.class.name}: #{exception.message}"
+      end
+
+      self.hostname        = local_hostname
+
+      also_use_rack_params_filters
+      find_session_data
+      clean_params
+      clean_rack_request_data
+    end
+
+    # Converts the given notice to XML
+    def to_xml
+      builder = Builder::XmlMarkup.new
+      builder.instruct!
+      xml = builder.notice(:version => Cloudtrapper::API_VERSION) do |notice|
+        notice.tag!("api-key", api_key)
+        notice.notifier do |notifier|
+          notifier.name(notifier_name)
+          notifier.version(notifier_version)
+          notifier.url(notifier_url)
+        end
+        notice.error do |error|
+          error.tag!('class', error_class)
+          error.message(error_message)
+          error.backtrace do |backtrace|
+            self.backtrace.lines.each do |line|
+              backtrace.line(:number => line.number,
+                             :file   => line.file,
+                             :method => line.method)
+            end
+          end
+        end
+        if url ||
+            controller ||
+            action ||
+            !parameters.blank? ||
+            !cgi_data.blank? ||
+            !session_data.blank?
+          notice.request do |request|
+            request.url(url)
+            request.component(controller)
+            request.action(action)
+            unless parameters.nil? || parameters.empty?
+              request.params do |params|
+                xml_vars_for(params, parameters)
+              end
+            end
+            unless session_data.nil? || session_data.empty?
+              request.session do |session|
+                xml_vars_for(session, session_data)
+              end
+            end
+            unless cgi_data.nil? || cgi_data.empty?
+              request.tag!("cgi-data") do |cgi_datum|
+                xml_vars_for(cgi_datum, cgi_data)
+              end
+            end
+          end
+        end
+        notice.tag!("server-environment") do |env|
+          env.tag!("project-root", project_root)
+          env.tag!("environment-name", environment_name)
+          env.tag!("hostname", hostname)
+        end
+      end
+      xml.to_s
+    end
+
+    # Determines if this notice should be ignored
+    def ignore?
+      ignored_class_names.include?(error_class) ||
+        ignore_by_filters.any? {|filter| filter.call(self) }
+    end
+
+    # Allows properties to be accessed using a hash-like syntax
+    #
+    # @example
+    #   notice[:error_message]
+    # @param [String] method The given key for an attribute
+    # @return The attribute value, or self if given +:request+
+    def [](method)
+      case method
+      when :request
+        self
+      else
+        send(method)
+      end
+    end
+
+    private
+
+    attr_writer :exception, :api_key, :backtrace, :error_class, :error_message,
+      :backtrace_filters, :parameters, :params_filters,
+      :environment_filters, :session_data, :project_root, :url, :ignore,
+      :ignore_by_filters, :notifier_name, :notifier_url, :notifier_version,
+      :component, :action, :cgi_data, :environment_name, :hostname
+
+    # Arguments given in the initializer
+    attr_accessor :args
+
+    # Gets a property named +attribute+ of an exception, either from an actual
+    # exception or a hash.
+    #
+    # If an exception is available, #from_exception will be used. Otherwise,
+    # a key named +attribute+ will be used from the #args.
+    #
+    # If no exception or hash key is available, +default+ will be used.
+    def exception_attribute(attribute, default = nil, &block)
+      (exception && from_exception(attribute, &block)) || args[attribute] || default
+    end
+
+    # Gets a property named +attribute+ from an exception.
+    #
+    # If a block is given, it will be used when getting the property from an
+    # exception. The block should accept and exception and return the value for
+    # the property.
+    #
+    # If no block is given, a method with the same name as +attribute+ will be
+    # invoked for the value.
+    def from_exception(attribute)
+      if block_given?
+        yield(exception)
+      else
+        exception.send(attribute)
+      end
+    end
+
+    # Removes non-serializable data from the given attribute.
+    # See #clean_unserializable_data
+    def clean_unserializable_data_from(attribute)
+      self.send(:"#{attribute}=", clean_unserializable_data(send(attribute)))
+    end
+
+    # Removes non-serializable data. Allowed data types are strings, arrays,
+    # and hashes. All other types are converted to strings.
+    # TODO: move this onto Hash
+    def clean_unserializable_data(data, stack = [])
+      return "[possible infinite recursion halted]" if stack.any?{|item| item == data.object_id }
+
+      if data.respond_to?(:to_hash)
+        data.to_hash.inject({}) do |result, (key, value)|
+          result.merge(key => clean_unserializable_data(value, stack + [data.object_id]))
+        end
+      elsif data.respond_to?(:to_ary)
+        data.to_ary.collect do |value|
+          clean_unserializable_data(value, stack + [data.object_id])
+        end
+      else
+        data.to_s
+      end
+    end
+
+    # Replaces the contents of params that match params_filters.
+    # TODO: extract this to a different class
+    def clean_params
+      clean_unserializable_data_from(:parameters)
+      filter(parameters)
+      if cgi_data
+        clean_unserializable_data_from(:cgi_data)
+        filter(cgi_data)
+      end
+      if session_data
+        clean_unserializable_data_from(:session_data)
+        filter(session_data)
+      end
+    end
+
+    def clean_rack_request_data
+      if cgi_data
+        cgi_data.delete("rack.request.form_vars")
+      end
+    end
+
+    def filter(hash)
+      if params_filters
+        hash.each do |key, value|
+          if filter_key?(key)
+            hash[key] = "[FILTERED]"
+          elsif value.respond_to?(:to_hash)
+            filter(hash[key])
+          end
+        end
+      end
+    end
+
+    def filter_key?(key)
+      params_filters.any? do |filter|
+        key.to_s.eql?(filter.to_s)
+      end
+    end
+
+    def find_session_data
+      self.session_data = args[:session_data] || args[:session] || rack_session || {}
+      self.session_data = session_data[:data] if session_data[:data]
+    end
+
+    # Converts the mixed class instances and class names into just names
+    # TODO: move this into Configuration or another class
+    def ignored_class_names
+      ignore.collect do |string_or_class|
+        if string_or_class.respond_to?(:name)
+          string_or_class.name
+        else
+          string_or_class
+        end
+      end
+    end
+
+    def xml_vars_for(builder, hash)
+      hash.each do |key, value|
+        if value.respond_to?(:to_hash)
+          builder.var(:key => key){|b| xml_vars_for(b, value.to_hash) }
+        else
+          builder.var(value.to_s, :key => key)
+        end
+      end
+    end
+
+    def rack_env(method)
+      rack_request.send(method) if rack_request
+    end
+
+    def rack_request
+      @rack_request ||= if args[:rack_env]
+        ::Rack::Request.new(args[:rack_env])
+      end
+    end
+
+    def action_dispatch_params
+      args[:rack_env]['action_dispatch.request.parameters'] if args[:rack_env]
+    end
+
+    def rack_session
+      args[:rack_env]['rack.session'] if args[:rack_env]
+    end
+
+    def also_use_rack_params_filters
+      if args[:rack_env]
+        @params_filters ||= []
+        @params_filters += rack_request.env["action_dispatch.parameter_filter"] || []
+      end
+    end
+
+    def local_hostname
+      Socket.gethostname
+    end
+
+  end
+end

data/lib/cloudtrapper/rack.rb

@@ -0,0 +1,55 @@
+module Cloudtrapper
+  # Middleware for Rack applications. Any errors raised by the upstream
+  # application will be delivered to Cloudtrapper and re-raised.
+  #
+  # Synopsis:
+  #
+  #   require 'rack'
+  #   require 'cloudtrapper'
+  #
+  #   Cloudtrapper.configure do |config|
+  #     config.api_key = 'my_api_key'
+  #   end
+  #
+  #   app = Rack::Builder.app do
+  #     run lambda { |env| raise "Rack down" }
+  #   end
+  #
+  #   use Cloudtrapper::Rack
+  #   run app
+  #
+  # Use a standard Cloudtrapper.configure call to configure your api key.
+  class Rack
+    def initialize(app)
+      @app = app
+      Cloudtrapper.configuration.logger ||= Logger.new STDOUT
+    end
+
+    def ignored_user_agent?(env)
+      true if Cloudtrapper.
+        configuration.
+        ignore_user_agent.
+        flatten.
+        any? { |ua| ua === env['HTTP_USER_AGENT'] }
+    end
+
+    def notify_cloudtrapper(exception,env)
+      Cloudtrapper.notify_or_ignore(exception,:rack_env => env) unless ignored_user_agent?(env)
+    end
+
+    def call(env)
+      begin
+        response = @app.call(env)
+      rescue Exception => raised
+        env['cloudtrapper.error_id'] = notify_cloudtrapper(raised,env)
+        raise
+      end
+
+      if env['rack.exception']
+        env['cloudtrapper.error_id'] = notify_cloudtrapper(env['rack.exception'],env)
+      end
+
+      response
+    end
+  end
+end

data/lib/cloudtrapper/rails/action_controller_catcher.rb

@@ -0,0 +1,30 @@
+module Cloudtrapper
+  module Rails
+    module ActionControllerCatcher
+
+      # Sets up an alias chain to catch exceptions when Rails does
+      def self.included(base) #:nodoc:
+        base.send(:alias_method, :rescue_action_in_public_without_cloudtrapper, :rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_cloudtrapper)
+      end
+
+      private
+
+      # 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_cloudtrapper(exception)
+        unless cloudtrapper_ignore_user_agent?
+          error_id = Cloudtrapper.notify_or_ignore(exception, cloudtrapper_request_data)
+          request.env['cloudtrapper.error_id'] = error_id
+        end
+        rescue_action_in_public_without_cloudtrapper(exception)
+      end
+
+      def cloudtrapper_ignore_user_agent? #:nodoc:
+        # Rails 1.2.6 doesn't have request.user_agent, so check for it here
+        user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
+        Cloudtrapper.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+      end
+    end
+  end
+end

data/lib/cloudtrapper/rails/controller_methods.rb

@@ -0,0 +1,74 @@
+module Cloudtrapper
+  module Rails
+    module ControllerMethods
+
+      def cloudtrapper_request_data
+        { :parameters       => cloudtrapper_filter_if_filtering(params.to_hash),
+          :session_data     => cloudtrapper_filter_if_filtering(cloudtrapper_session_data),
+          :controller       => params[:controller],
+          :action           => params[:action],
+          :url              => cloudtrapper_request_url,
+          :cgi_data         => cloudtrapper_filter_if_filtering(request.env) }
+      end
+
+      private
+
+      # This method should be used for sending manual notifications while you are still
+      # inside the controller. Otherwise it works like Cloudtrapper.notify.
+      def notify_cloudtrapper(hash_or_exception)
+        unless cloudtrapper_local_request?
+          Cloudtrapper.notify(hash_or_exception, cloudtrapper_request_data)
+        end
+      end
+
+      def cloudtrapper_local_request?
+        if defined?(::Rails.application.config)
+          ::Rails.application.config.consider_all_requests_local || (request.local? && (!request.env["HTTP_X_FORWARDED_FOR"]))
+        else
+          consider_all_requests_local || (local_request? && (!request.env["HTTP_X_FORWARDED_FOR"]))
+        end
+      end
+
+      def cloudtrapper_ignore_user_agent? #:nodoc:
+        # Rails 1.2.6 doesn't have request.user_agent, so check for it here
+        user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
+        Cloudtrapper.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+      end
+
+
+      def cloudtrapper_filter_if_filtering(hash)
+        return hash if ! hash.is_a?(Hash)
+
+
+        if respond_to?(:filter_parameters) # Rails 2
+          filter_parameters(hash)
+        elsif defined?(ActionDispatch::Http::ParameterFilter) # Rails 3
+          ActionDispatch::Http::ParameterFilter.new(::Rails.application.config.filter_parameters).filter(hash)
+        else
+          hash
+        end rescue hash
+
+      end
+
+      def cloudtrapper_session_data
+        if session.respond_to?(:to_hash)
+          session.to_hash
+        else
+          session.data
+        end
+      end
+
+      def cloudtrapper_request_url
+        url = "#{request.protocol}#{request.host}"
+
+        unless [80, 443].include?(request.port)
+          url << ":#{request.port}"
+        end
+
+        url << request.fullpath
+        url
+      end
+    end
+  end
+end
+

data/lib/cloudtrapper/rails/error_lookup.rb

@@ -0,0 +1,33 @@
+module Cloudtrapper
+  module Rails
+    module ErrorLookup
+
+      # Sets up an alias chain to catch exceptions when Rails does
+      def self.included(base) #:nodoc:
+        base.send(:alias_method, :rescue_action_locally_without_cloudtrapper, :rescue_action_locally)
+        base.send(:alias_method, :rescue_action_locally, :rescue_action_locally_with_cloudtrapper)
+      end
+
+      private
+
+      def rescue_action_locally_with_cloudtrapper(exception)
+        result = rescue_action_locally_without_cloudtrapper(exception)
+
+        if Cloudtrapper.configuration.development_lookup
+          path   = File.join(File.dirname(__FILE__), '..', '..', 'templates', 'rescue.erb')
+          notice = Cloudtrapper.build_lookup_hash_for(exception, cloudtrapper_request_data)
+
+          result << @template.render(
+            :file          => path,
+            :use_full_path => false,
+            :locals        => { :host    => Cloudtrapper.configuration.host,
+                                :api_key => Cloudtrapper.configuration.api_key,
+                                :notice  => notice })
+        end
+
+        result
+      end
+    end
+  end
+end
+

data/lib/cloudtrapper/rails/javascript_notifier.rb

@@ -0,0 +1,48 @@
+module Cloudtrapper
+  module Rails
+    module JavascriptNotifier
+      def self.included(base) #:nodoc:
+        base.send :helper_method, :cloudtrapper_javascript_notifier
+      end
+
+      private
+
+      def cloudtrapper_javascript_notifier
+        return unless Cloudtrapper.configuration.public?
+
+        path = File.join File.dirname(__FILE__), '..', '..', 'templates', 'javascript_notifier.erb'
+        host = Cloudtrapper.configuration.host.dup
+        port = Cloudtrapper.configuration.port
+        host << ":#{port}" unless [80, 443].include?(port)
+
+        options              = {
+          :file              => path,
+          :layout            => false,
+          :use_full_path     => false,
+          :locals            => {
+            :host            => host,
+            :api_key         => Cloudtrapper.configuration.js_api_key,
+            :environment     => Cloudtrapper.configuration.environment_name,
+            :action_name     => action_name,
+            :controller_name => controller_name,
+            :url             => request.url
+          }
+        }
+
+        res = if @template
+          @template.render(options)
+        else
+          render_to_string(options)
+        end
+
+        if res.respond_to?(:html_safe)
+          res.html_safe
+        else
+          res
+        end
+
+      end
+
+    end
+  end
+end

data/lib/cloudtrapper/rails/middleware/exceptions_catcher.rb

@@ -0,0 +1,29 @@
+module Cloudtrapper
+  module Rails
+    module Middleware
+      module ExceptionsCatcher
+        def self.included(base)
+          base.send(:alias_method_chain,:render_exception,:cloudtrapper)
+        end
+
+        def skip_user_agent?(env)
+          user_agent = env["HTTP_USER_AGENT"]
+          ::Cloudtrapper.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+        rescue
+          false
+        end
+
+        def render_exception_with_cloudtrapper(env,exception)
+          controller = env['action_controller.instance']
+          env['cloudtrapper.error_id'] = Cloudtrapper.
+            notify_or_ignore(exception,
+                   controller.try(:cloudtrapper_request_data) || :rack_env => env) unless skip_user_agent?(env)
+          if defined?(controller.rescue_action_in_public_without_cloudtrapper)
+            controller.rescue_action_in_public_without_cloudtrapper(exception)
+          end
+          render_exception_without_cloudtrapper(env,exception)
+        end
+      end
+    end
+  end
+end

data/lib/cloudtrapper/rails.rb

@@ -0,0 +1,40 @@
+require 'cloudtrapper'
+require 'cloudtrapper/rails/controller_methods'
+require 'cloudtrapper/rails/action_controller_catcher'
+require 'cloudtrapper/rails/error_lookup'
+require 'cloudtrapper/rails/javascript_notifier'
+
+module Cloudtrapper
+  module Rails
+    def self.initialize
+      if defined?(ActionController::Base)
+        ActionController::Base.send(:include, Cloudtrapper::Rails::ActionControllerCatcher)
+        ActionController::Base.send(:include, Cloudtrapper::Rails::ErrorLookup)
+        ActionController::Base.send(:include, Cloudtrapper::Rails::ControllerMethods)
+        ActionController::Base.send(:include, Cloudtrapper::Rails::JavascriptNotifier)
+      end
+
+      rails_logger = if defined?(::Rails.logger)
+                       ::Rails.logger
+                     elsif defined?(RAILS_DEFAULT_LOGGER)
+                       RAILS_DEFAULT_LOGGER
+                     end
+
+      if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:middleware)
+        ::Rails.configuration.middleware.insert_after 'ActionController::Failsafe',
+                                                      Cloudtrapper::Rack
+        ::Rails.configuration.middleware.insert_after 'Rack::Lock',
+                                                      Cloudtrapper::UserInformer
+      end
+
+      Cloudtrapper.configure(true) do |config|
+        config.logger           = rails_logger
+        config.environment_name = defined?(::Rails.env) && ::Rails.env || defined?(RAILS_ENV) && RAILS_ENV
+        config.project_root     = defined?(::Rails.root) && ::Rails.root || defined?(RAILS_ROOT) && RAILS_ROOT
+        config.framework        = defined?(::Rails.version) && "Rails: #{::Rails.version}" || defined?(::Rails::VERSION::STRING) && "Rails: #{::Rails::VERSION::STRING}"
+      end
+    end
+  end
+end
+
+Cloudtrapper::Rails.initialize