honeybadger 2.7.2 → 3.0.0.beta1

data/lib/honeybadger/cli/helpers.rb

@@ -1,160 +0,0 @@
-require 'logger'
-
-module Honeybadger
-  module CLI
-    module Helpers
-      def rails?(opts = {})
-        @rails ||= load_rails(opts)
-      end
-
-      def load_rails(opts = {})
-        begin
-          require 'honeybadger/init/rails'
-          if ::Rails::VERSION::MAJOR >= 3
-            say("Detected Rails #{::Rails::VERSION::STRING}") if opts[:verbose]
-          else
-            say("Error: Rails #{::Rails::VERSION::STRING} is unsupported.", :red)
-            exit(1)
-          end
-        rescue LoadError
-          say("Rails was not detected, loading standalone.") if opts[:verbose]
-          return @rails = false
-        rescue StandardError => e
-          say("Error while detecting Rails: #{e.class} -- #{e.message}", :red)
-          exit(1)
-        end
-
-        begin
-          require File.expand_path('config/application')
-        rescue LoadError
-          say('Error: could not load Rails application. Please ensure you run this command from your project root.', :red)
-          exit(1)
-        end
-
-        @rails = true
-      end
-
-      def load_rails_env(opts = {})
-        return false unless rails?(opts)
-
-        puts('Loading Rails environment') if opts[:verbose]
-        ::Rails.application.require_environment!
-
-        true
-      end
-
-      def rails_framework_opts
-        return {} unless defined?(::Rails)
-
-        {
-          :root           => ::Rails.root,
-          :env            => ::Rails.env,
-          :'config.path'  => ::Rails.root.join('config', 'honeybadger.yml'),
-          :framework      => :rails
-        }
-      end
-
-      def test_exception_class
-        exception_name = ENV['EXCEPTION'] || 'HoneybadgerTestingException'
-        Object.const_get(exception_name)
-      rescue
-        Object.const_set(exception_name, Class.new(Exception))
-      end
-
-      def send_test(verbose = true)
-        if defined?(::Rails)
-          rails_test(verbose)
-        else
-          standalone_test
-        end
-      end
-
-      def standalone_test
-        Honeybadger.notify(test_exception_class.new('Testing honeybadger via "honeybadger test". If you can see this, it works.'))
-      end
-
-      def rails_test(verbose = true)
-        if verbose
-          ::Rails.logger = if defined?(::ActiveSupport::TaggedLogging)
-                             ::ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
-                           else
-                             Logger.new(STDOUT)
-                           end
-          ::Rails.logger.level = Logger::INFO
-        end
-
-        # Suppress error logging in Rails' exception handling middleware. Rails 3.0
-        # uses ActionDispatch::ShowExceptions to rescue/show exceptions, but does
-        # not log anything but application trace. Rails 3.2 now falls back to
-        # logging the framework trace (moved to ActionDispatch::DebugExceptions),
-        # which caused cluttered output while running the test task.
-        defined?(::ActionDispatch::DebugExceptions) and
-          ::ActionDispatch::DebugExceptions.class_eval { def logger(*args) ; @logger ||= Logger.new('/dev/null') ; end }
-        defined?(::ActionDispatch::ShowExceptions) and
-        ::ActionDispatch::ShowExceptions.class_eval { def logger(*args) ; @logger ||= Logger.new('/dev/null') ; end }
-
-        # Detect and disable the better_errors gem
-        if defined?(::BetterErrors::Middleware)
-          say('Better Errors detected: temporarily disabling middleware.', :yellow)
-          ::BetterErrors::Middleware.class_eval { def call(env) @app.call(env); end }
-        end
-
-        begin
-          require './app/controllers/application_controller'
-        rescue LoadError
-          nil
-        end
-
-        unless defined?(::ApplicationController)
-          say('Error: No ApplicationController found.', :red)
-          return false
-        end
-
-        say('Setting up the Controller.')
-        eval(<<-CONTROLLER)
-        class Honeybadger::TestController < ApplicationController
-          # This is to bypass any filters that may prevent access to the action.
-          if respond_to?(:prepend_before_action)
-            prepend_before_action :test_honeybadger
-          else
-            prepend_before_filter :test_honeybadger
-          end
-
-          def test_honeybadger
-            puts "Raising '#{test_exception_class.name}' to simulate application failure."
-            raise #{test_exception_class}.new, 'Testing honeybadger via "honeybadger test", it works.'
-          end
-
-          # Ensure we actually have an action to go to.
-          def verify; end
-        end
-        CONTROLLER
-
-        ::Rails.application.routes.tap do |r|
-          # RouteSet#disable_clear_and_finalize prevents existing routes from
-          # being cleared. We'll set it back to the original value when we're
-          # done so not to mess with Rails state.
-          d = r.disable_clear_and_finalize
-          begin
-            r.disable_clear_and_finalize = true
-            r.clear!
-            r.draw do
-              match 'verify' => 'honeybadger/test#verify', :as => 'verify', :via => :get
-            end
-            ::Rails.application.routes_reloader.paths.each{ |path| load(path) }
-            ::ActiveSupport.on_load(:action_controller) { r.finalize! }
-          ensure
-            r.disable_clear_and_finalize = d
-          end
-        end
-
-        say('Processing request.')
-
-        ssl = defined?(::Rails.configuration.force_ssl) && ::Rails.configuration.force_ssl
-        env = ::Rack::MockRequest.env_for("http#{ ssl ? 's' : nil }://www.example.com/verify", 'REMOTE_ADDR' => '127.0.0.1')
-
-        ::Rails.application.call(env)
-      end
-    end
-  end
-end

data/lib/honeybadger/config/callbacks.rb

@@ -1,70 +0,0 @@
-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/plugins/unicorn.rb

@@ -1,27 +0,0 @@
-require 'honeybadger/plugin'
-require 'honeybadger/agent'
-
-module Honeybadger
-  module Plugins
-    module Unicorn
-      module AfterForkExtension
-        def self.included(base)
-          base.send(:alias_method, :init_worker_process_without_honeybadger, :init_worker_process)
-          base.send(:alias_method, :init_worker_process, :init_worker_process_with_honeybadger)
-        end
-
-        def init_worker_process_with_honeybadger(*args, &block)
-          init_worker_process_without_honeybadger(*args, &block).tap do
-            Honeybadger::Agent.fork
-          end
-        end
-      end
-
-      Plugin.register do
-        requirement { defined?(::Unicorn::HttpServer) }
-
-        execution { ::Unicorn::HttpServer.send(:include, AfterForkExtension) }
-      end
-    end
-  end
-end

data/lib/honeybadger/rack/metrics_reporter.rb

@@ -1,16 +0,0 @@
-require 'honeybadger'
-
-module Honeybadger
-  module Rack
-    class MetricsReporter
-      def initialize(app, config)
-        @app = app
-        config.logger.warn('DEPRECATION WARNING: `Honeybadger::Rack::MetricsReporter` no longer has any effect and will be removed.')
-      end
-
-      def call(env)
-        @app.call(env)
-      end
-    end
-  end
-end

data/lib/honeybadger/rack/request_hash.rb

@@ -1,55 +0,0 @@
-module Honeybadger
-  module Rack
-    # Internal: Constructs a request hash from a Rack::Request matching the
-    # /v1/notices API specification.
-    class RequestHash < ::Hash
-      # Internal
-      CGI_BLACKLIST = ['QUERY_STRING', 'RAW_POST_DATA', 'ORIGINAL_FULLPATH', 'REQUEST_URI'].freeze
-      CGI_KEY_REGEXP = /\A[A-Z_]+\Z/
-
-      def initialize(request)
-        self[:url] = extract_url(request)
-        self[:params] = extract_params(request)
-        self[:component] = self[:params]['controller']
-        self[:action] = self[:params]['action']
-        self[:session] = extract_session(request)
-        self[:cgi_data] = extract_cgi_data(request)
-      end
-
-      private
-
-      def extract_url(request)
-        request.env['honeybadger.request.url'] || request.url
-      rescue => e
-        # TODO: Log these errors
-        "Error: #{e.message}"
-      end
-
-      def extract_params(request)
-        (request.env['action_dispatch.request.parameters'] || request.params).to_hash || {}
-      rescue => e
-        { error: "Failed to access params -- #{e.message}" }
-      end
-
-      def extract_session(request)
-        request.session.to_hash
-      rescue => e
-        # Rails raises ArgumentError when `config.secret_token` is missing, and
-        # ActionDispatch::Session::SessionRestoreError when the session can't be
-        # restored.
-        { error: "Failed to access session data -- #{e.message}" }
-      end
-
-      def extract_cgi_data(request)
-        request.env.reject {|k,_| cgi_blacklist?(k) }
-      end
-
-      def cgi_blacklist?(key)
-        return true if CGI_BLACKLIST.include?(key)
-        return true unless key.match(CGI_KEY_REGEXP)
-
-        false
-      end
-    end
-  end
-end