honeybadger 1.0.0

data/lib/honeybadger/capistrano.rb

@@ -0,0 +1,43 @@
+# Defines deploy:notify_honeybadger which will send information about the deploy to Honeybadger.
+require 'capistrano'
+
+module Honeybadger
+  module Capistrano
+    def self.load_into(configuration)
+      configuration.load do
+        after "deploy",            "honeybadger:deploy"
+        after "deploy:migrations", "honeybadger:deploy"
+
+        namespace :honeybadger do
+          desc <<-DESC
+            Notify Honeybadger of the deployment by running the notification on the REMOTE machine.
+              - Run remotely so we use remote API keys, environment, etc.
+          DESC
+          task :deploy, :except => { :no_release => true } do
+            rails_env = fetch(:rails_env, "production")
+            honeybadger_env = fetch(:honeybadger_env, fetch(:rails_env, "production"))
+            local_user = ENV['USER'] || ENV['USERNAME']
+            executable = RUBY_PLATFORM.downcase.include?('mswin') ? fetch(:rake, 'rake.bat') : fetch(:rake, 'rake')
+            directory = configuration.current_release
+            notify_command = "cd #{directory}; #{executable} RAILS_ENV=#{rails_env} honeybadger:deploy TO=#{honeybadger_env} REVISION=#{current_revision} REPO=#{repository} USER=#{local_user}"
+            notify_command << " DRY_RUN=true" if dry_run
+            notify_command << " API_KEY=#{ENV['API_KEY']}" if ENV['API_KEY']
+            logger.info "Notifying Honeybadger of Deploy (#{notify_command})"
+            if configuration.dry_run
+              logger.info "DRY RUN: Notification not actually run."
+            else
+              result = ""
+              run(notify_command, :once => true) { |ch, stream, data| result << data }
+              # TODO: Check if SSL is active on account via result content.
+            end
+            logger.info "Honeybadger Notification Complete."
+          end
+        end
+      end
+    end
+  end
+end
+
+if Capistrano::Configuration.instance
+  Honeybadger::Capistrano.load_into(Capistrano::Configuration.instance)
+end

data/lib/honeybadger/configuration.rb

@@ -0,0 +1,273 @@
+module Honeybadger
+  class Configuration
+    OPTIONS = [:api_key, :backtrace_filters, :development_environments, :environment_name,
+               :host, :http_open_timeout, :http_read_timeout, :ignore, :ignore_by_filters,
+               :ignore_user_agent, :notifier_name, :notifier_url, :notifier_version,
+               :params_filters, :project_root, :port, :protocol, :proxy_host, :proxy_pass,
+               :proxy_port, :proxy_user, :secure, :use_system_ssl_cert_chain, :framework,
+               :user_information, :rescue_rake_exceptions].freeze
+
+    # The API key for your project, found on the project edit form.
+    attr_accessor :api_key
+
+    # The host to connect to (defaults to honeybadger.io).
+    attr_accessor :host
+
+    # The port on which your Honeybadger server runs (defaults to 443 for secure
+    # connections, 80 for insecure connections).
+    attr_accessor :port
+
+    # +true+ for https connections, +false+ for http connections.
+    attr_accessor :secure
+
+    # +true+ to use whatever CAs OpenSSL has installed on your system. +false+ to use the ca-bundle.crt file included in Honeybadger itself (reccomended and default)
+    attr_accessor :use_system_ssl_cert_chain
+
+    # The HTTP open timeout in seconds (defaults to 2).
+    attr_accessor :http_open_timeout
+
+    # The HTTP read timeout in seconds (defaults to 5).
+    attr_accessor :http_read_timeout
+
+    # The hostname of your proxy server (if using a proxy)
+    attr_accessor :proxy_host
+
+    # The port of your proxy server (if using a proxy)
+    attr_accessor :proxy_port
+
+    # The username to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_user
+
+    # The password to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_pass
+
+    # A list of parameters that should be filtered out of what is sent to Honeybadger.
+    # By default, all "password" attributes will have their contents replaced.
+    attr_reader :params_filters
+
+    # A list of filters for cleaning and pruning the backtrace. See #filter_backtrace.
+    attr_reader :backtrace_filters
+
+    # A list of filters for ignoring exceptions. See #ignore_by_filter.
+    attr_reader :ignore_by_filters
+
+    # A list of exception classes to ignore. The array can be appended to.
+    attr_reader :ignore
+
+    # A list of user agents that are being ignored. The array can be appended to.
+    attr_reader :ignore_user_agent
+
+    # A list of environments in which notifications should not be sent.
+    attr_accessor :development_environments
+
+    # The name of the environment the application is running in
+    attr_accessor :environment_name
+
+    # The path to the project in which the error occurred, such as the Rails.root
+    attr_accessor :project_root
+
+    # The name of the notifier library being used to send notifications (such as "Honeybadger Notifier")
+    attr_accessor :notifier_name
+
+    # The version of the notifier library being used to send notifications (such as "1.0.2")
+    attr_accessor :notifier_version
+
+    # The url of the notifier library being used to send notifications
+    attr_accessor :notifier_url
+
+    # The logger used by Honeybadger
+    attr_accessor :logger
+
+    # The text that the placeholder is replaced with. {{error_id}} is the actual error number.
+    attr_accessor :user_information
+
+    # The framework Honeybadger is configured to use
+    attr_accessor :framework
+
+    # Should Honeybadger catch exceptions from Rake tasks?
+    # (boolean or nil; set to nil to catch exceptions when rake isn't running from a terminal; default is nil)
+    attr_accessor :rescue_rake_exceptions
+
+    DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
+
+    DEFAULT_BACKTRACE_FILTERS = [
+      lambda { |line|
+        if defined?(Honeybadger.configuration.project_root) && Honeybadger.configuration.project_root.to_s != '' 
+          line.sub(/#{Honeybadger.configuration.project_root}/, "[PROJECT_ROOT]")
+        else
+          line
+        end
+      },
+      lambda { |line| line.gsub(/^\.\//, "") },
+      lambda { |line|
+        if defined?(Gem)
+          Gem.path.inject(line) do |line, path|
+            line.gsub(/#{path}/, "[GEM_ROOT]")
+          end
+        end
+      },
+      lambda { |line| line if line !~ %r{lib/honeybadger} }
+    ].freeze
+
+    IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
+                      'ActionController::RoutingError',
+                      'ActionController::InvalidAuthenticityToken',
+                      'CGI::Session::CookieStore::TamperedWithCookie',
+                      'ActionController::UnknownAction',
+                      'AbstractController::ActionNotFound',
+                      'Mongoid::Errors::DocumentNotFound']
+
+    alias_method :secure?, :secure
+    alias_method :use_system_ssl_cert_chain?, :use_system_ssl_cert_chain
+
+    def initialize
+      @secure                   = false
+      @use_system_ssl_cert_chain= false
+      @host                     = 'api.honeybadger.io'
+      @http_open_timeout        = 2
+      @http_read_timeout        = 5
+      @params_filters           = DEFAULT_PARAMS_FILTERS.dup
+      @backtrace_filters        = DEFAULT_BACKTRACE_FILTERS.dup
+      @ignore_by_filters        = []
+      @ignore                   = IGNORE_DEFAULT.dup
+      @ignore_user_agent        = []
+      @development_environments = %w(development test cucumber)
+      @notifier_name            = 'Honeybadger Notifier'
+      @notifier_version         = VERSION
+      @notifier_url             = 'https://github.com/honeybadger/honeybadger'
+      @framework                = 'Standalone'
+      @user_information         = 'Honeybadger Error {{error_id}}'
+      @rescue_rake_exceptions   = nil
+    end
+
+    # Public: 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.
+    #
+    # &block - The new backtrace filter.
+    #
+    # Examples:
+    #
+    #    config.filter_bracktrace do |line|
+    #      line.gsub(/^#{Rails.root}/, "[Rails.root]")
+    #    end
+    #
+    # Yields a line in the backtrace.
+    def filter_backtrace(&block)
+      self.backtrace_filters << block
+    end
+
+    # Public: Takes a block and adds it to the list of ignore filters. When
+    # the filters run, the block will be handed the exception.
+    #
+    # &block - The new ignore filter
+    #          If the block returns true the exception will be ignored, otherwise it
+    #          will be processed by honeybadger.
+    #
+    # Examples:
+    #
+    #   config.ignore_by_filter do |exception_data|
+    #     true if exception_data[:error_class] == "RuntimeError"
+    #   end
+    #
+    # Yields the the exception data given to Honeybadger.notify
+    def ignore_by_filter(&block)
+      self.ignore_by_filters << block
+    end
+
+    # Public: Overrides the list of default ignored errors.
+    #
+    # names - A list of exceptions to ignore.
+    #
+    # Returns nothing
+    def ignore_only=(names)
+      @ignore = [names].flatten
+    end
+
+    # Public: Overrides the list of default ignored user agents
+    #
+    # names - A list of user agents to ignore
+    #
+    # Returns nothing
+    def ignore_user_agent_only=(names)
+      @ignore_user_agent = [names].flatten
+    end
+
+    # Public: Allows config options to be read like a hash
+    #
+    # option - Key for a given attribute
+    #
+    # Returns value of requested attribute
+    def [](option)
+      send(option)
+    end
+
+    # Public
+    # Returns a hash of all configurable options
+    def to_hash
+      OPTIONS.inject({}) do |hash, option|
+        hash[option.to_sym] = self.send(option)
+        hash
+      end
+    end
+
+    # Public
+    #
+    # hash - A set of configuration options that will take precedence over the defaults
+    #
+    # Returns a hash of all configurable options merged with +hash+
+    def merge(hash)
+      to_hash.merge(hash)
+    end
+
+    # Public: Determines if the notifier will send notices.
+    #
+    # Returns false if in a development environment, true otherwise.
+    def public?
+      !development_environments.include?(environment_name)
+    end
+
+    def port
+      @port || default_port
+    end
+
+    # Public: Determines whether protocol should be "http" or "https".
+    #
+    # Returns 'http' if you've set secure to false in
+    # configuration, and 'https' otherwise.
+    def protocol
+      if secure?
+        'https'
+      else
+        'http'
+      end
+    end
+
+    def ca_bundle_path
+      if use_system_ssl_cert_chain? && File.exist?(OpenSSL::X509::DEFAULT_CERT_FILE)
+        OpenSSL::X509::DEFAULT_CERT_FILE
+      else
+        local_cert_path # ca-bundle.crt built from source, see resources/README.md
+      end
+    end
+
+    def local_cert_path
+      File.expand_path(File.join("..", "..", "..", "resources", "ca-bundle.crt"), __FILE__)
+    end
+
+    private
+
+    # Private: Determines what port should we use for sending notices.
+    #
+    # Returns 443 if you've set secure to true in your
+    # configuration, and 80 otherwise.
+    def default_port
+      if secure?
+        443
+      else
+        80
+      end
+    end
+  end
+end
+

data/lib/honeybadger/notice.rb

@@ -0,0 +1,314 @@
+require 'socket'
+
+module Honeybadger
+  class Notice
+    # The exception that caused this notice, if any
+    attr_reader :exception
+
+    # 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 "Honeybadger 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.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
+
+    # Public: Template used to create JSON payload
+    #
+    # Returns JSON representation of notice
+    def as_json(options = {})
+      {
+        :notifier => {
+          :name => notifier_name,
+          :url => notifier_url,
+          :version => notifier_version
+        },
+        :error => {
+          :class => error_class,
+          :message => error_message,
+          :backtrace => backtrace
+        },
+        :request => {
+          :url => url,
+          :component => component,
+          :action => action,
+          :params => parameters,
+          :session => session_data,
+          :cgi_data => cgi_data
+        },
+        :server => {
+          :project_root => project_root,
+          :environment_name => environment_name,
+          :hostname => hostname
+        }
+      }
+    end
+
+    # Public: Creates JSON
+    #
+    # Returns valid JSON representation of notice
+    def to_json(*a)
+      as_json.to_json(*a)
+    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
+
+    # Public: Allows properties to be accessed using a hash-like syntax
+    #
+    # method - The given key for an attribute
+    #
+    # Examples:
+    #
+    #   notice[:error_message]
+    #
+    # Returns the attribute value, or self if given +:request+
+    def [](method)
+      case method
+      when :request
+        self
+      else
+        send(method)
+      end
+    end
+
+    private
+
+    attr_writer :exception, :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
+
+    # Private: Arguments given in the initializer
+    attr_accessor :args
+
+    # Private: 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
+
+    # Private: 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
+
+    # Private: 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
+
+    # Private: 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
+
+    # Private: 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
+
+    # Private: 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 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