honeybadger 1.16.7 → 2.0.0.beta.1

data/lib/honeybadger/config/callbacks.rb

@@ -0,0 +1,70 @@
+module Honeybadger
+  class Config
+    class Callbacks
+      attr_reader :backtrace_filter, :exception_filter, :exception_fingerprint
+
+      def initialize
+        @backtrace_filter = nil
+        @exception_filter = nil
+        @exception_fingerprint = 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.backtrace_filter do |line|
+      #      line.gsub(/^#{Rails.root}/, "[Rails.root]")
+      #    end
+      #
+      # Yields a line in the backtrace.
+      def backtrace_filter(&block)
+        @backtrace_filter = Proc.new if block_given?
+        @backtrace_filter
+      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.exception_filter do |exception|
+      #     if exception.class < MyError
+      #       nil
+      #     else
+      #       exception
+      #     end
+      #   end
+      #
+      # Yields the the exception data given to Honeybadger.notify
+      def exception_filter(&block)
+        @exception_filter = Proc.new if block_given?
+        @exception_filter
+      end
+
+      # Public: Generate custom fingerprint (optional)
+      #
+      # block - An optional block returning object responding to #to_s
+      #
+      # Examples
+      #
+      #   config.exception_fingerprint do |notice|
+      #     [notice[:error_class], notice[:component], notice[:backtrace].to_s].join(':')
+      #   end
+      #
+      # Returns configured fingerprint generator (should respond to #call(notice))
+      def exception_fingerprint
+        @exception_fingerprint = Proc.new if block_given?
+        @exception_fingerprint
+      end
+    end
+  end
+end

data/lib/honeybadger/config/defaults.rb

@@ -0,0 +1,175 @@
+require 'socket'
+
+module Honeybadger
+  class Config
+    IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
+                      'ActionController::RoutingError',
+                      'ActionController::InvalidAuthenticityToken',
+                      'CGI::Session::CookieStore::TamperedWithCookie',
+                      'ActionController::UnknownAction',
+                      'AbstractController::ActionNotFound',
+                      'Mongoid::Errors::DocumentNotFound',
+                      'Sinatra::NotFound'].map(&:freeze).freeze
+
+    OPTIONS = {
+      enabled: {
+        description: 'Determines if Honeybadger will start.',
+        default: true
+      },
+      debug: {
+        description: 'Forces metrics and traces to be reported every 10 seconds rather than 60.',
+        default: false
+      },
+      api_key: {
+        description: 'The API key for your Honeybadger project.',
+        default: nil
+      },
+      hostname: {
+        description: 'The hostname of the current box.',
+        default: Socket.gethostname
+      },
+      root: {
+        description: 'The project\'s absolute root path.',
+        default: Dir.pwd
+      },
+      backend: {
+        description: 'An alternate backend to use for reporting data.',
+        default: nil
+      },
+      env: {
+        description: 'The current application\'s environment name.',
+        default: ENV['HONEYBADGER_ENV']
+      },
+      public: {
+        description: 'Enable reporting of data.',
+        default: nil
+      },
+      environments: {
+        description: 'Public environments which are enabled for reporting automatically.',
+        default: ['production'.freeze, 'staging'.freeze].freeze
+      },
+      plugins: {
+        description: 'An optional list of plugins to load. Default is to load all plugins.',
+        default: nil
+      },
+      :'plugins.skip' => {
+        description: 'An optional list of plugins to skip.',
+        default: nil
+      },
+      :'config.path' => {
+        description: 'The path (absolute, or relative from config.root) to the project\'s YAML configuration file.',
+        default: ENV['HONEYBADGER_CONFIG_PATH'] || ['honeybadger.yml', 'config/honeybadger.yml']
+      },
+      :'logging.path' => {
+        description: 'The path (absolute, or relative from config.root) to the log file.',
+        default: nil
+      },
+      :'logging.level' => {
+        description: 'The log level.',
+        default: 'INFO'
+      },
+      :'connection.secure' => {
+        description: 'Use SSL when sending data.',
+        default: true
+      },
+      :'connection.host' => {
+        description: 'The host to use when sending data.',
+        default: 'api.honeybadger.io'.freeze
+      },
+      :'connection.port' => {
+        description: 'The port to use when sending data.',
+        default: nil
+      },
+      :'connection.system_ssl_cert_chain' => {
+        description: 'Use the system\'s SSL certificate chain (if available).',
+        default: false
+      },
+      :'connection.http_open_timeout' => {
+        description: 'The HTTP open timeout when connecting to the server.',
+        default: 2
+      },
+      :'connection.http_read_timeout' => {
+        description: 'The HTTP read timeout when connecting to the server.',
+        default: 5
+      },
+      :'connection.proxy_host' => {
+        description: 'The proxy host to use when sending data.',
+        default: nil
+      },
+      :'connection.proxy_port' => {
+        description: 'The proxy port to use when sending data.',
+        default: nil
+      },
+      :'connection.proxy_user' => {
+        description: 'The proxy user to use when sending data.',
+        default: nil
+      },
+      :'connection.proxy_pass' => {
+        description: 'The proxy password to use when sending data.',
+        default: nil
+      },
+      :'request.filter_keys' => {
+        description: 'A list of keys to filter when sending request data.',
+        default: ['password'.freeze, 'password_confirmation'.freeze].freeze
+      },
+      :'request.exclude_keys' => {
+        description: 'A list of top-level keys to exclude when sending request data.',
+        default: [].freeze
+      },
+      :'user_informer.enabled' => {
+        description: 'Enable the UserInformer middleware.',
+        default: true
+      },
+      :'user_informer.info' => {
+        description: 'Replacement string for HTML comment in templates.',
+        default: 'Honeybadger Error {{error_id}}'.freeze
+      },
+      :'feedback.enabled' => {
+        description: 'Enable the UserFeedback middleware.',
+        default: true
+      },
+      :'exceptions.enabled' => {
+        description: 'Enable automatic reporting of exceptions.',
+        default: true
+      },
+      :'exceptions.ignore' => {
+        description: 'A list of exceptions to ignore.',
+        default: IGNORE_DEFAULT
+      },
+      :'exceptions.ignored_user_agents' => {
+        description: 'A list of user agents to ignore.',
+        default: [].freeze
+      },
+      :'exceptions.rescue_rake' => {
+        description: 'Enable rescuing exceptions in rake tasks.',
+        default: true
+      },
+      :'exceptions.source_radius' => {
+        description: 'The number of lines before and after the source when reporting snippets.',
+        default: 2
+      },
+      :'exceptions.local_variables' => {
+        description: 'Enable sending local variables. Requires binding_of_caller to be loaded.',
+        default: false
+      },
+      :'metrics.enabled' => {
+        description: 'Enable sending metrics.',
+        default: true
+      },
+      :'metrics.gc_profiler' => {
+        description: 'Enable sending GC metrics (GC::Profiler must be enabled)',
+        default: false
+      },
+      :'traces.enabled' => {
+        description: 'Enable sending traces.',
+        default: true
+      },
+      :'traces.threshold' => {
+        description: 'The threshold in seconds to send traces.',
+        default: 2000
+      }
+    }.freeze
+
+    DEFAULTS = Hash[OPTIONS.map{|k,v| [k, v[:default]] }].freeze
+  end
+end

data/lib/honeybadger/config/env.rb

@@ -0,0 +1,40 @@
+module Honeybadger
+  class Config
+    class Env < ::Hash
+      CONFIG_KEY = /\AHONEYBADGER_(.+)\Z/.freeze
+      CONFIG_MAPPING = Hash[DEFAULTS.keys.map {|k| [k.to_s.upcase.gsub(KEY_REPLACEMENT, '_'), k] }].freeze
+      ARRAY_VALUES = Regexp.new('\s*,\s*').freeze
+
+      def initialize(env = ENV)
+        env.each_pair do |k,v|
+          next unless k.match(CONFIG_KEY)
+          next if DISALLOWED_KEYS.include?(CONFIG_MAPPING[$1])
+          self[CONFIG_MAPPING[$1] || $1.downcase.to_sym] = cast_value(v)
+        end
+      end
+
+      private
+
+      def cast_value(value)
+        if value.match(ARRAY_VALUES)
+          return value.split(ARRAY_VALUES).map(&method(:cast_value))
+        end
+
+        case value
+        when /\Atrue\Z/
+          true
+        when /\Afalse\Z/
+          false
+        when /\Anil\Z/
+          nil
+        when /\A\d+\z/
+          value.to_i
+        when /\A\d+\.\d+\z/
+          value.to_f
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/config/yaml.rb

@@ -0,0 +1,43 @@
+require 'pathname'
+require 'yaml'
+
+module Honeybadger
+  class Config
+    class Yaml < ::Hash
+      def initialize(path, env = 'production')
+        @path = Pathname.new(path)
+
+        if !@path.exist?
+          raise ConfigError, "The configuration file #{@path} was not found."
+        elsif !@path.file?
+          raise ConfigError, "The configuration file #{@path} is not a file."
+        elsif !@path.writable?
+          raise ConfigError, "The configuration file #{@path} is not writable."
+        else
+          yaml = YAML.load(@path.read)
+          override = yaml.delete(env)
+          update(dotify_keys(yaml.merge(override || {})))
+        end
+
+      rescue StandardError => e
+        raise ConfigError, "An unknown error occured: #{e.class} -- #{e.message}\n\t#{e.backtrace.first}"
+      end
+
+      private
+
+      def dotify_keys(hash, key_prefix = nil)
+        {}.tap do |new_hash|
+          hash.each_pair do |k,v|
+            k = [key_prefix, k].compact.join('.')
+            if v.kind_of?(Hash)
+              new_hash.update(dotify_keys(v, k))
+            else
+              next if DISALLOWED_KEYS.include?(k.to_sym)
+              new_hash[k.to_sym] = v
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/const.rb

@@ -0,0 +1,28 @@
+require 'honeybadger/version'
+
+module Honeybadger
+  autoload :Agent, 'honeybadger/agent'
+  autoload :Backend, 'honeybadger/backend'
+  autoload :Backtrace, 'honeybadger/backtrace'
+  autoload :Config, 'honeybadger/config'
+  autoload :Logging, 'honeybadger/logging'
+  autoload :Notice, 'honeybadger/notice'
+  autoload :Worker, 'honeybadger/worker'
+  autoload :Trace, 'honeybadger/trace'
+  autoload :Plugin, 'honeybadger/plugin'
+
+  module Rack
+    autoload :ErrorNotifier, 'honeybadger/rack/error_notifier'
+    autoload :MetricsReporter, 'honeybadger/rack/metrics_reporter'
+    autoload :UserFeedback, 'honeybadger/rack/user_feedback'
+    autoload :UserInformer, 'honeybadger/rack/user_informer'
+    autoload :RequestHash, 'honeybadger/rack/request_hash'
+  end
+
+  module Util
+    autoload :Sanitizer, 'honeybadger/util/sanitizer'
+    autoload :RequestSanitizer, 'honeybadger/util/request_sanitizer'
+    autoload :Stats, 'honeybadger/util/stats'
+    autoload :HTTP, 'honeybadger/util/http'
+  end
+end

data/lib/honeybadger/init/rails.rb

@@ -0,0 +1,84 @@
+require 'rails'
+require 'yaml'
+
+module Honeybadger
+  module Init
+    module Rails
+      class Railtie < ::Rails::Railtie
+        initializer 'honeybadger.install' do
+          config = Config.new(local_config)
+          if Honeybadger.start(config)
+            ::Rails.application.config.middleware.tap do |middleware|
+              middleware.insert(0, 'Honeybadger::Rack::ErrorNotifier', config)
+              middleware.insert_before('Honeybadger::Rack::ErrorNotifier', 'Honeybadger::Rack::UserFeedback', config)
+              middleware.insert_before('Honeybadger::Rack::UserFeedback', 'Honeybadger::Rack::UserInformer', config)
+            end
+
+            if config[:'traces.enabled']
+              ActiveSupport::Notifications.subscribe('start_processing.action_controller') do |name, started, finished, id, data|
+                Trace.create(id)
+              end
+
+              ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
+                event = ActiveSupport::Notifications::Event.new(*args)
+                Trace.current.add_query(event) if Trace.current and event.name != 'SCHEMA'
+              end
+
+              ActiveSupport::Notifications.subscribe(/^render_(template|action|collection)\.action_view/) do |*args|
+                event = ActiveSupport::Notifications::Event.new(*args)
+                Trace.current.add(event) if Trace.current
+              end
+
+              ActiveSupport::Notifications.subscribe('net_http.request') do |*args|
+                event = ActiveSupport::Notifications::Event.new(*args)
+                Trace.current.add(event) if Trace.current
+              end
+
+              ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
+                event = ActiveSupport::Notifications::Event.new(*args)
+                if Trace.current && event.payload[:controller] && event.payload[:action]
+                  Trace.current.complete(event)
+                end
+              end
+            end
+
+            if config[:'metrics.enabled']
+              ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
+                event = ActiveSupport::Notifications::Event.new(*args)
+                status = event.payload[:exception] ? 500 : event.payload[:status]
+                Agent.timing("app.request.#{status}", event.duration)
+
+                controller = event.payload[:controller]
+                action = event.payload[:action]
+                if controller && action
+                  Agent.timing("app.controller.#{controller}.#{action}.total", event.duration)
+                  Agent.timing("app.controller.#{controller}.#{action}.view", event.payload[:view_runtime]) if event.payload[:view_runtime]
+                  Agent.timing("app.controller.#{controller}.#{action}.db", event.payload[:db_runtime]) if event.payload[:db_runtime]
+                end
+              end
+            end
+          end
+        end
+
+        private
+
+        def local_config
+          {
+            :root           => ::Rails.root.to_s,
+            :env            => ::Rails.env,
+            :'config.path'  => ::Rails.root.join('config', 'honeybadger.yml'),
+            :logger         => Logging::FormattedLogger.new(::Rails.logger),
+            :framework      => :rails,
+            :api_key        => secrets_api_key
+          }
+        end
+
+        def secrets_api_key
+          if defined?(::Rails.application.secrets)
+            ::Rails.application.secrets.honeybadger_api_key
+          end
+        end
+      end
+    end
+  end
+end