yogi_berra 0.0.1

data/README.md

@@ -0,0 +1,51 @@
+Yogi Berra
+==========
+
+ "If the world were perfect, it wouldn't be." - Yogi Berra
+
+Yogi Berra was the best catcher of all time.
+This gem will catch all of your rails error in production or development and store them in mongodb if
+it can. It uses the mongodb_ruby_driver in a non-blocking way.
+
+    Mongo::MongoClient.new(host, port, :w => 0)
+
+The `:w => 0` option here makes requests to the mongodb server not wait for a response.
+This will begin to fill a buffer when there is no connection. When the connection returns
+the buffer will be entered into the database. There can be data loss if the buffer overflows.
+There are some messages in the logs which will tell you if the connection is down.
+This makes the catcher work when it does and not crash or slow when it doesn't.
+
+Installation
+------------
+
+add yogi_berra to your Gemfile:
+
+    gem 'yogi_berra'
+
+Create a yogi.yml file in rails root config/ folder. Here is a sample:
+
+    defaults: &defaults
+      username: yogi
+      password: berra
+
+    development:
+      <<: *defaults
+      database: yogi_berra
+      host: localhost
+      port: 27017
+
+Thanks
+------
+
+To :
+  - Thoughtbot Airbrake:
+    https://github.com/airbrake/airbrake/tree/master/lib/airbrake
+    This gem is awesome and was the base for most of the code here.
+
+  - Exception Engine:
+    https://github.com/Consoci8/exception_engine
+    Which is an app which was the inital fork to start this code base.
+    Just took out the need for mongoid, and a rails app. Made it into a gem
+    that will later have a rails app to view the exceptions. Exception engine also
+    credits Thoughtbot for the Hoptoad::Notice part of the code. Hoptoad is now airbrake.
+

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'rubygems/package_task'
+require 'rspec/core/rake_task'
+
+spec = eval(File.read('yogi_berra_client.gemspec'))
+
+Gem::PackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end
+
+RSpec::Core::RakeTask.new
+task :default => :spec

data/lib/yogi_berra/action_controller_catcher.rb

@@ -0,0 +1,45 @@
+# Adapted from Airbrake code https://github.com/airbrake/airbrake/blob/master/lib/airbrake/rails/action_controller_catcher.rb
+module YogiBerra
+  module ActionControllerCatcher
+    # Sets up an alias chain to catch exceptions for Rails 2
+    def self.included(base)
+      YogiBerra::Catcher.load_db_settings
+      if base.method_defined?(:rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public_without_yogi, :rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_yogi)
+        if YogiBerra::Catcher.settings
+          base.send(:alias_method, :rescue_action_locally_without_yogi, :rescue_action_locally)
+          base.send(:alias_method, :rescue_action_locally, :rescue_action_locally_with_yogi)
+        end
+      end
+    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_yogi(exception)
+      rescue_action_yogi(exception)
+      rescue_action_in_public_without_yogi(exception)
+    end
+
+    def rescue_action_locally_with_yogi(exception)
+      rescue_action_yogi(exception)
+      rescue_action_locally_without_yogi(exception)
+    end
+
+    def rescue_action_yogi(exception)
+        environment = {
+          :session => session,
+          :params => params,
+          :user_agent => request.headers['HTTP_USER_AGENT'],
+          :server_name => request.headers['SERVER_NAME'],
+          :server_port => request.headers['SERVER_PORT'],
+          :server_address => request.headers['SERVER_ADDR'],
+          :remote_address => request.remote_ip
+        }
+      error_id = YogiBerra.exceptionize(exception, environment, YogiBerra::Catcher.connection)
+      request.env['yogi_berra.error_id'] = error_id
+    end
+
+  end
+end

data/lib/yogi_berra/backtrace.rb

@@ -0,0 +1,100 @@
+# Credits to Thoughtbot's Hoptoad::Backtrace
+module YogiBerra
+  # Front end to parsing the backtrace for each notice
+  class Backtrace
+
+    # Handles backtrace parsing line by line
+    class Line
+
+      INPUT_FORMAT = %r{^([^:]+):(\d+)(?::in `([^']+)')?$}.freeze
+
+      # The file portion of the line (such as app/models/user.rb)
+      attr_reader :file
+
+      # The line number portion of the line
+      attr_reader :number
+
+      # The method of the line (such as index)
+      attr_reader :method
+
+      # Parses a single line of a given backtrace
+      # @param [String] unparsed_line The raw line from +caller+ or some backtrace
+      # @return [Line] The parsed backtrace line
+      def self.parse(unparsed_line)
+        _, file, number, method = unparsed_line.match(INPUT_FORMAT).to_a
+        new(file, number, method)
+      end
+
+      def initialize(file, number, method)
+        self.file   = file
+        self.number = number
+        self.method = method
+      end
+
+      # Reconstructs the line in a readable fashion
+      def to_s
+        "#{file}:#{number}:in `#{method}'"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      def inspect
+        "<Line:#{to_s}>"
+      end
+
+      private
+
+      attr_writer :file, :number, :method
+    end
+
+    # holder for an Array of Backtrace::Line instances
+    attr_reader :lines
+
+    def self.parse(ruby_backtrace, opts = {})
+      ruby_lines = split_multiline_backtrace(ruby_backtrace)
+
+      filters = opts[:filters] || []
+      filtered_lines = ruby_lines.to_a.map do |line|
+        filters.inject(line) do |line, proc|
+          proc.call(line)
+        end
+      end.compact
+
+      lines = filtered_lines.collect do |unparsed_line|
+        Line.parse(unparsed_line)
+      end
+
+      instance = new(lines)
+    end
+
+    def initialize(lines)
+      self.lines = lines
+    end
+
+    def inspect
+      "<Backtrace: " + lines.collect { |line| line.inspect }.join(", ") + ">"
+    end
+
+    def ==(other)
+      if other.respond_to?(:lines)
+        lines == other.lines
+      else
+        false
+      end
+    end
+
+    private
+
+    attr_writer :lines
+
+    def self.split_multiline_backtrace(backtrace)
+      if backtrace.to_a.size == 1
+        backtrace.to_a.first.split(/\n\s*/)
+      else
+        backtrace
+      end
+    end
+  end
+end

data/lib/yogi_berra/catcher.rb

@@ -0,0 +1,45 @@
+require 'mongo'
+
+module YogiBerra
+  class Catcher
+    cattr_accessor :settings, :mongo_client, :connection
+
+    class << self
+      def load_db_settings
+        begin
+          File.open("#{Rails.root}/config/yogi.yml", 'r') do |f|
+            yaml_file = YAML.load(f)
+            @@settings = yaml_file["#{Rails.env}"] if yaml_file
+          end
+        rescue
+          $stderr.puts "[YogiBerra Error] No such file: #{Rails.root}/config/yogi.yml"
+        end
+      end
+
+      def db_client(host, port)
+        # :w => 0 set the default write concern to 0, this allows writes to be non-blocking
+        # by not waiting for a response from mongodb
+        @@mongo_client = Mongo::MongoClient.new(host, port, :w => 0)
+      rescue
+        Rails.logger.error "[YogiBerra Error] Couldn't connect to the mongo database on host: #{host} port: #{port}."
+        nil
+      end
+
+      def quick_connection
+        settings = @@settings || load_db_settings
+        if settings
+          host = settings["host"]
+          port = settings["port"]
+          client = db_client(host, port)
+          if client
+            @@connection = client[settings["database"]]
+          else
+            Rails.logger.error "[YogiBerra Error] Couldn't connect to the mongo database on host: #{host} port: #{port}."
+          end
+        else
+          Rails.logger.error "[YogiBerra Error] Couldn't load the yogi.yml file."
+        end
+      end
+    end
+  end
+end

data/lib/yogi_berra/data.rb

@@ -0,0 +1,34 @@
+require 'mongo'
+
+module YogiBerra
+  class Data
+    def self.store!(exception, environment, client)
+      data = parse_exception(exception)
+      if environment
+        session = environment.delete(:session)
+        data[:session] = parse_session(session) if session
+        data.merge!(environment)
+      end
+      client["caught_exceptions"].insert(data)
+    end
+
+    def self.parse_exception(notice)
+      data_hash = {
+        :error_class => notice.error_class,
+        :error_message => notice.error_message
+      }
+      if notice.backtrace.lines.any?
+        data_hash[:backtraces] = notice.backtrace.lines.collect(&:to_s)
+      end
+      data_hash[:created_at] = Time.now.utc
+      data_hash
+    end
+
+    def self.parse_session(session)
+      session.inject({}) do |result, element|
+        result[element.first] = element.last.respond_to?(:as_json) ? element.last.as_json(:except => ["password"]) : element.last
+        result
+      end
+    end
+  end
+end

data/lib/yogi_berra/engine.rb

@@ -0,0 +1,5 @@
+module YogiBerra
+  class Engine < Rails::Engine
+    config.app_middleware.use "YogiBerra::ExceptionMiddleware"
+  end
+end

data/lib/yogi_berra/exception_middleware.rb

@@ -0,0 +1,41 @@
+module YogiBerra
+  class ExceptionMiddleware
+    def initialize(app)
+      @app = app
+      YogiBerra::Catcher.quick_connection
+    end
+
+    def call(env)
+      begin
+        response = dup._call(env)
+        environment = {
+          :session => env['rack.session'],
+          :params => env['action_controller.request.path_parameters'].merge(env['rack.request.query_hash']),
+          :user_agent => env['HTTP_USER_AGENT'],
+          :server_name => env['SERVER_NAME'],
+          :server_port => env['SERVER_PORT'],
+          :server_address => env['SERVER_ADDR'],
+          :remote_address => env['REMOTE_ADDR']
+        }
+      rescue Exception => raised
+        YogiBerra.exceptionize(raised, environment, YogiBerra::Catcher.connection)
+        raise raised
+      end
+
+      if env['rack.exception']
+        YogiBerra.exceptionize(raised, environment, YogiBerra::Catcher.connection)
+      end
+      response
+    end
+
+    def _call(env)
+      @status, @headers, @response = @app.call(env)
+      [@status, @headers, self]
+    end
+
+    def each(&block)
+      @response.each(&block)
+    end
+
+  end
+end

data/lib/yogi_berra/notice.rb

@@ -0,0 +1,336 @@
+require 'builder'
+
+# Credits to Thoughtbot's Hoptoad::Notice
+module YogiBerra
+  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 "Hoptoad 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
+
+    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
+
+      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 => "1.0") 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)
+        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
+
+    # 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)
+      if data.respond_to?(:to_hash)
+        data.to_hash.inject({}) do |result, (key, value)|
+          result.merge(key => clean_unserializable_data(value))
+        end
+      elsif data.respond_to?(:to_ary)
+        data.collect do |value|
+          clean_unserializable_data(value)
+        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.include?(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
+
+  end
+end