honeybadger 1.16.7 → 2.0.0.beta.1

data/lib/honeybadger/rails3_tasks.rb

@@ -1,94 +0,0 @@
-require 'honeybadger'
-require File.join(File.dirname(__FILE__), 'shared_tasks')
-
-namespace :honeybadger do
-  desc "Verify your gem installation by sending a test exception to the honeybadger service"
-  task :test => :environment do
-    Rails.logger = if defined?(ActiveSupport::TaggedLogging)
-                     ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
-                   else
-                     Logger.new(STDOUT)
-                   end
-    Rails.logger.level = Logger::INFO
-
-    Honeybadger.configure(true) do |config|
-      config.logger = Rails.logger
-      config.debug = true
-      config.development_environments = []
-      config.rescue_rake_exceptions = false
-    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.
-    class ActionDispatch::DebugExceptions ; def logger(*args) ; @logger ||= Logger.new('/dev/null') ; end ; end
-    class ActionDispatch::ShowExceptions ; def logger(*args) ; @logger ||= Logger.new('/dev/null') ; end ; end
-
-    # Detect and disable the better_errors gem
-    if defined? BetterErrors::Middleware
-      puts 'Better Errors detected: temporarily disabling middleware.'
-      class BetterErrors::Middleware ; def call(env) @app.call(env); end ; end
-    end
-
-    begin
-      require './app/controllers/application_controller'
-    rescue LoadError
-      nil
-    end
-
-    class HoneybadgerTestingException < RuntimeError; end
-
-    unless Honeybadger.configuration.api_key
-      puts "Honeybadger needs an API key configured! Check the README to see how to add it."
-      exit
-    end
-
-    if Honeybadger.configuration.async?
-      puts "Temporarily disabling asynchronous delivery"
-      Honeybadger.configuration.async = nil
-    end
-
-    puts "Configuration:"
-    Honeybadger.configuration.to_hash.each do |key, value|
-      puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
-    end
-
-    unless defined?(ApplicationController)
-      puts "No ApplicationController found"
-      exit
-    end
-
-    puts 'Setting up the Controller.'
-    class ApplicationController
-      # This is to bypass any filters that may prevent access to the action.
-      prepend_before_filter :test_honeybadger
-      def test_honeybadger
-        puts "Raising '#{exception_class.name}' to simulate application failure."
-        raise exception_class.new, 'Testing honeybadger via "rake honeybadger:test". If you can see this, it works.'
-      end
-
-      # Ensure we actually have an action to go to.
-      def verify; end
-
-      def exception_class
-        exception_name = ENV['EXCEPTION'] || "HoneybadgerTestingException"
-        Object.const_get(exception_name)
-      rescue
-        Object.const_set(exception_name, Class.new(Exception))
-      end
-    end
-
-    Rails.application.routes.draw do
-      match 'verify' => 'application#verify', :as => 'verify', :via => :get
-    end
-
-    puts '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

data/lib/honeybadger/railtie.rb

@@ -1,52 +0,0 @@
-require 'honeybadger'
-require 'rails'
-
-module Honeybadger
-  class Railtie < Rails::Railtie
-    rake_tasks do
-      require 'honeybadger/rake_handler'
-      require "honeybadger/rails3_tasks"
-    end
-
-    initializer "honeybadger.use_rack_middleware" do |app|
-      app.config.middleware.insert 0, "Honeybadger::Rack::UserInformer"
-      app.config.middleware.insert_after "Honeybadger::Rack::UserInformer","Honeybadger::Rack::UserFeedback"
-      app.config.middleware.insert_after "Honeybadger::Rack::UserFeedback","Honeybadger::Rack::ErrorNotifier"
-    end
-
-    config.after_initialize do
-      Honeybadger.configure(true) do |config|
-        config.logger           ||= ::Rails.logger
-        config.environment_name ||= ::Rails.env
-        config.project_root     ||= ::Rails.root
-        config.framework        = "Rails: #{::Rails::VERSION::STRING}"
-      end
-
-      ActiveSupport.on_load(:action_controller) do
-        # Lazily load action_controller methods
-        #
-        require 'honeybadger/rails/controller_methods'
-
-        include Honeybadger::Rails::ControllerMethods
-      end
-
-      if defined?(::ActionDispatch::DebugExceptions)
-        # We should catch the exceptions in ActionDispatch::DebugExceptions in Rails 3.2.x.
-        #
-        require 'honeybadger/rails/middleware/exceptions_catcher'
-        ::ActionDispatch::DebugExceptions.send(:include,Honeybadger::Rails::Middleware::ExceptionsCatcher)
-      elsif defined?(::ActionDispatch::ShowExceptions)
-        # ActionDispatch::DebugExceptions is not defined in Rails 3.0.x and 3.1.x so
-        # catch the exceptions in ShowExceptions.
-        #
-        require 'honeybadger/rails/middleware/exceptions_catcher'
-        ::ActionDispatch::ShowExceptions.send(:include,Honeybadger::Rails::Middleware::ExceptionsCatcher)
-      end
-
-      Honeybadger.ping(Honeybadger.configuration)
-
-      # Inject last, in case we're depending on configuration from ping.
-      Honeybadger::Dependency.inject!
-    end
-  end
-end

data/lib/honeybadger/rake_handler.rb

@@ -1,66 +0,0 @@
-# Patch Rake::Application to handle errors with Honeybadger
-module Honeybadger::RakeHandler
-  def self.included(klass)
-    klass.class_eval do
-      include Rake087Methods unless defined?(Rake::VERSION) && Rake::VERSION >= '0.9.0'
-      alias_method :display_error_message_without_honeybadger, :display_error_message
-      alias_method :display_error_message, :display_error_message_with_honeybadger
-    end
-  end
-
-  def display_error_message_with_honeybadger(ex)
-    if Honeybadger.sender && Honeybadger.configuration &&
-      (Honeybadger.configuration.rescue_rake_exceptions || 
-       (Honeybadger.configuration.rescue_rake_exceptions===nil && !self.tty_output?))
-
-      Honeybadger.notify_or_ignore(ex, :component => reconstruct_command_line)
-      Honeybadger.context.clear!
-    end
-
-    display_error_message_without_honeybadger(ex)
-  end
-
-  def reconstruct_command_line
-    "rake #{ARGV.join( ' ' )}"
-  end
-
-  # This module brings Rake 0.8.7 error handling to 0.9.0 standards
-  module Rake087Methods
-    # Method taken from Rake 0.9.0 source
-    #
-    # Provide standard exception handling for the given block.
-    def standard_exception_handling
-      begin
-        yield
-      rescue SystemExit => ex
-        # Exit silently with current status
-        raise
-      rescue OptionParser::InvalidOption => ex
-        $stderr.puts ex.message
-        exit(false)
-      rescue Exception => ex
-        # Exit with error message
-        display_error_message(ex)
-        exit(false)
-      end
-    end
-
-    # Method extracted from Rake 0.8.7 source
-    def display_error_message(ex)
-      $stderr.puts "#{name} aborted!"
-      $stderr.puts ex.message
-      if options.trace
-        $stderr.puts ex.backtrace.join("\n")
-      else
-        $stderr.puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
-        $stderr.puts "(See full trace by running task with --trace)"
-      end
-    end
-  end
-end
-
-Rake.application.instance_eval do
-  class << self
-    include Honeybadger::RakeHandler
-  end
-end

data/lib/honeybadger/sender.rb

@@ -1,185 +0,0 @@
-require 'zlib'
-require 'stringio'
-
-module Honeybadger
-  class Sender
-    NOTICES_URI = '/v1/notices/'.freeze
-    HTTP_ERRORS = [Timeout::Error,
-                   Errno::EINVAL,
-                   Errno::ECONNRESET,
-                   EOFError,
-                   Net::HTTPBadResponse,
-                   Net::HTTPHeaderSyntaxError,
-                   Net::ProtocolError,
-                   Errno::ECONNREFUSED].freeze
-
-    def initialize(options = {})
-      [ :api_key,
-        :proxy_host,
-        :proxy_port,
-        :proxy_user,
-        :proxy_pass,
-        :protocol,
-        :host,
-        :port,
-        :secure,
-        :use_system_ssl_cert_chain,
-        :http_open_timeout,
-        :http_read_timeout
-      ].each do |option|
-        instance_variable_set("@#{option}", options[option])
-      end
-    end
-
-    # Public: Sends the notice data off to Honeybadger for processing.
-    #
-    # notice - The notice to be sent (Notice, Hash or JSON string)
-    #
-    # Returns error id from successful response
-    def send_to_honeybadger(notice)
-      if !Honeybadger.configuration.features['notices']
-        log(:error, "Can't send error report -- the gem has been deactivated by the remote service.\n\t" \
-            "This is usually a result of an expired plan. Please check your payment info and restart your app.\n\t" \
-            "If you continue to receive this message, contact support@honeybadger.io.")
-        return nil
-      end
-
-      api_key = api_key_ok?(!notice.is_a?(String) && notice['api_key']) or return nil
-
-      data = notice.is_a?(String) ? notice : notice.to_json
-
-      response = send_request(url.path, data, {'X-API-Key' => api_key})
-
-      if Net::HTTPSuccess === response
-        log(Honeybadger.configuration.debug ? :info : :debug, "Success: #{response.class}", response, data)
-        JSON.parse(response.body).fetch('id')
-      else
-        Honeybadger.configuration.features['notices'] = false if Net::HTTPForbidden === response
-        log(:error, "Failure: #{response.class}", response, data)
-        log_original_exception(notice)
-        nil
-      end
-    rescue => e
-      log(:error, "[Honeybadger::Sender#send_to_honeybadger] Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
-      log_original_exception(notice)
-      nil
-    end
-
-    def ping(data = {})
-      return nil unless api_key_ok?
-
-      data = data.to_json
-      response = send_request('/v1/ping/', data)
-
-      if Net::HTTPSuccess === response
-        log(Honeybadger.configuration.debug ? :info : :debug, "Ping Success: #{response.class}", response)
-        JSON.parse(response.body)
-      else
-        log(:error, "Ping Failure: #{response.class}", response, data)
-        nil
-      end
-    rescue => e
-      log(:error, "[Honeybadger::Sender#ping] Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
-      nil
-    end
-
-    attr_reader :api_key,
-      :proxy_host,
-      :proxy_port,
-      :proxy_user,
-      :proxy_pass,
-      :protocol,
-      :host,
-      :port,
-      :secure,
-      :use_system_ssl_cert_chain,
-      :http_open_timeout,
-      :http_read_timeout
-
-    alias_method :secure?, :secure
-    alias_method :use_system_ssl_cert_chain?, :use_system_ssl_cert_chain
-
-    private
-
-    def url
-      URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
-    end
-
-    def api_key_ok?(api_key = nil)
-      api_key ||= self.api_key
-      unless api_key =~ /\S/
-        log(:error, "API key not found.")
-        return nil
-      end
-
-      api_key
-    end
-
-    def log(level, message, response = nil, data = nil)
-      # Log result:
-      Honeybadger.write_verbose_log(message, level)
-
-      # Log debug information:
-      Honeybadger.report_environment_info
-      Honeybadger.report_response_body(response.body) if response && response.body =~ /\S/
-      Honeybadger.write_verbose_log("Notice: #{data}", :debug) if data && Honeybadger.configuration.debug
-    end
-
-    def send_request(path, data, headers = {})
-      http_connection.post(path, compress(data), http_headers(headers))
-    rescue *HTTP_ERRORS => e
-      log(:error, "Unable to contact the Honeybadger server. HTTP Error=#{e}")
-      nil
-    end
-
-    def http_connection
-      setup_http_connection
-    end
-
-    def http_headers(headers=nil)
-      {}.tap do |hash|
-        hash.merge!(HEADERS)
-        hash.merge!({'X-API-Key' => api_key})
-        hash.merge!(headers) if headers
-      end
-    end
-
-    def setup_http_connection
-      http_class = Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass)
-      http = http_class.new(url.host, url.port)
-
-      http.read_timeout = http_read_timeout
-      http.open_timeout = http_open_timeout
-
-      if secure?
-        http.use_ssl     = true
-
-        http.ca_file      = Honeybadger.configuration.ca_bundle_path
-        http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
-      else
-        http.use_ssl     = false
-      end
-
-      http
-    rescue => e
-      log(:error, "[Honeybadger::Sender#setup_http_connection] Failure initializing the HTTP connection.\nError: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
-      raise e
-    end
-
-    def log_original_exception(notice)
-      if Honeybadger.configuration.log_exception_on_send_failure
-        if notice.respond_to?(:exception) && notice.respond_to?(:backtrace)
-          message = "#{notice.error_message}\n#{notice.backtrace}"
-        else
-          message = "#{notice}"
-        end
-
-        Honeybadger.write_verbose_log("Original Exception: #{message}", :error)
-      end
-    end
-
-    def compress(string, level = Zlib::DEFAULT_COMPRESSION)
-      Zlib::Deflate.deflate(string, level)
-    end
-  end
-end

data/lib/honeybadger/shared_tasks.rb

@@ -1,56 +0,0 @@
-namespace :honeybadger do
-  desc "Notify Honeybadger of a new deploy."
-  task :deploy do
-    require 'honeybadger_tasks'
-
-    if defined?(Rails.root)
-      initializer_file = Rails.root.join('config', 'initializers','honeybadger.rb')
-
-      if initializer_file.exist?
-        load initializer_file
-      else
-        Rake::Task[:environment].invoke
-      end
-    end
-
-    HoneybadgerTasks.deploy(:environment    => ENV['TO'],
-                            :revision       => ENV['REVISION'],
-                            :repository     => ENV['REPO'],
-                            :local_username => ENV['USER'],
-                            :api_key        => ENV['API_KEY'],
-                            :dry_run        => ENV['DRY_RUN'])
-  end
-
-  task :deploy_with_environment => [:environment, :deploy]
-
-  task :log_stdout do
-    require 'logger'
-    RAILS_DEFAULT_LOGGER = Logger.new(STDOUT)
-  end
-
-  namespace :heroku do
-    desc "Install Heroku deploy notifications addon"
-    task :add_deploy_notification => [:environment] do
-      def heroku_var(var, app_name, default = nil)
-        app = app_name ? "--app #{app_name}" : ''
-        result = Bundler.with_clean_env { `heroku config:get #{var} #{app} 2> /dev/null`.strip }
-        result.split.find(lambda { default }) {|x| x =~ /\S/ }
-      end
-
-      heroku_rails_env = heroku_var('RAILS_ENV', ENV['APP'], Honeybadger.configuration.environment_name)
-      heroku_api_key = heroku_var('HONEYBADGER_API_KEY', ENV['APP'], Honeybadger.configuration.api_key)
-
-      unless heroku_api_key =~ /\S/ && heroku_rails_env =~ /\S/
-        puts "WARNING: We were unable to detect the configuration from your Heroku environment."
-        puts "Your Heroku application environment may not be configured correctly."
-        puts "Have you configured multiple Heroku apps? Try using APP=[app name]'" unless ENV['APP']
-        exit
-      end
-
-      command = %Q(heroku addons:add deployhooks:http --url="https://api.honeybadger.io/v1/deploys?deploy[environment]=#{heroku_rails_env}&deploy[local_username]={{user}}&deploy[revision]={{head}}&api_key=#{heroku_api_key}"#{ENV['APP'] ? " --app #{ENV['APP']}" : ''})
-
-      puts "\nRunning:\n#{command}\n"
-      puts `#{command}`
-    end
-  end
-end