honeybadger 1.16.7 → 2.0.0.beta.1

data/lib/honeybadger/stats.rb

@@ -1,29 +0,0 @@
-module Honeybadger
-  class Stats
-    HAS_MEM = File.exists?("/proc/meminfo")
-    HAS_LOAD = File.exists?("/proc/loadavg")
-
-    class << self
-      def all
-        { :mem => memory, :load => load }
-      end
-
-      # From https://github.com/bloopletech/webstats/blob/master/server/data_providers/mem_info.rb
-      def memory
-        out = {}
-        if HAS_MEM
-          out[:total], out[:free], out[:buffers], out[:cached] = IO.readlines("/proc/meminfo")[0..4].map { |l| l =~ /^.*?\: +(.*?) kB$/; ($1.to_i / 1024.0).to_f }
-          out[:free_total] = out[:free] + out[:buffers] + out[:cached]
-        end
-        out
-      end
-
-      # From https://github.com/bloopletech/webstats/blob/master/server/data_providers/cpu_info.rb
-      def load
-        out = {}
-        out[:one], out[:five], out[:fifteen] = IO.read("/proc/loadavg").split(' ', 4).map(&:to_f) if HAS_LOAD
-        out
-      end
-    end
-  end
-end

data/lib/honeybadger/tasks.rb

@@ -1,95 +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 => ['honeybadger:log_stdout', :environment] do
-    RAILS_DEFAULT_LOGGER.level = Logger::INFO
-
-    require 'action_controller/test_process'
-
-    begin
-      Dir["app/controllers/application*.rb"].each { |file| require(File.expand_path(file)) }
-    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
-
-    Honeybadger.configure(true) do |config|
-      config.debug = true
-      config.development_environments = []
-      config.rescue_rake_exceptions = false
-    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
-
-    catcher = Honeybadger::Rails::ActionControllerCatcher
-    in_controller = ApplicationController.included_modules.include?(catcher)
-    in_base = ActionController::Base.included_modules.include?(catcher)
-    if !in_controller || !in_base
-      puts "Rails initialization did not occur"
-      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
-
-      def rescue_action(exception)
-        rescue_action_in_public exception
-      end
-
-      # Ensure we actually have an action to go to.
-      def verify; end
-
-      def consider_all_requests_local
-        false
-      end
-
-      def local_request?
-        false
-      end
-
-      def exception_class
-        exception_name = ENV['EXCEPTION'] || "HoneybadgerTestingException"
-        exception_name.split("::").inject(Object){|klass, name| klass.const_get(name)}
-      rescue
-        Object.const_set(exception_name.gsub(/:+/, "_"), Class.new(Exception))
-      end
-
-      def logger
-        nil
-      end
-    end
-    class HoneybadgerVerificationController < ApplicationController; end
-
-    puts 'Processing request.'
-    request = ActionController::TestRequest.new("REQUEST_URI" => "/honeybadger_verification_controller")
-    response = ActionController::TestResponse.new
-    HoneybadgerVerificationController.new.process(request, response)
-  end
-end

data/lib/honeybadger/user_feedback.rb

@@ -1,8 +0,0 @@
-module Honeybadger
-  class UserFeedback < Rack::UserFeedback
-    def initialize(app)
-      warn '[DEPRECATION] Honeybadger::UserFeedback is deprecated in 2.0. Use Honeybadger::Rack::UserFeedback.'
-      super
-    end
-  end
-end

data/lib/honeybadger/user_informer.rb

@@ -1,8 +0,0 @@
-module Honeybadger
-  class UserInformer < Rack::UserInformer
-    def initialize(app)
-      warn '[DEPRECATION] Honeybadger::UserInformer is deprecated in 2.0. Use Honeybadger::Rack::UserInformer.'
-      super
-    end
-  end
-end

data/lib/honeybadger_tasks.rb

@@ -1,69 +0,0 @@
-require 'net/http'
-require 'uri'
-
-# Capistrano tasks for notifying Honeybadger of deploys
-module HoneybadgerTasks
-
-  # Public: Alerts Honeybadger of a deploy.
-  #
-  # opts - Data about the deploy that is set to Honeybadger
-  #        :api_key        - Api key of you Honeybadger application
-  #        :environment    - Environment of the deploy (production, staging)
-  #        :revision       - The given revision/sha that is being deployed
-  #        :repository     - Address of your repository to help with code lookups
-  #        :local_username - Who is deploying
-  #
-  # Returns true or false
-  def self.deploy(opts = {})
-    api_key = opts.delete(:api_key) || Honeybadger.configuration.api_key
-    unless api_key =~ /\S/
-      $stderr.puts "I don't seem to be configured with an API key.  Please check your configuration."
-      return false
-    end
-
-    unless opts[:environment] =~ /\S/
-      $stderr.puts "I don't know to which environment you are deploying (use the TO=production option)."
-      return false
-    end
-
-    dry_run = opts.delete(:dry_run)
-    params = {}
-    opts.each {|k,v| params["deploy[#{k}]"] = v }
-
-    host = Honeybadger.configuration.host || 'api.honeybadger.io'
-    port = Honeybadger.configuration.port
-
-    proxy = Net::HTTP.Proxy(Honeybadger.configuration.proxy_host,
-                            Honeybadger.configuration.proxy_port,
-                            Honeybadger.configuration.proxy_user,
-                            Honeybadger.configuration.proxy_pass)
-    http = proxy.new(host, port)
-
-    # Handle Security
-    if Honeybadger.configuration.secure?
-      http.use_ssl      = true
-      http.ca_file      = Honeybadger.configuration.ca_bundle_path
-      http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
-    end
-
-    post = Net::HTTP::Post.new("/v1/deploys")
-    post.set_form_data(params)
-    post['X-API-Key'] = api_key
-
-    if dry_run
-      puts http.inspect, params.inspect
-      return true
-    else
-      response = http.request(post)
-
-      if Net::HTTPSuccess === response
-        puts "Successfully recorded deployment"
-        return true
-      else
-        $stderr.puts "Error recording deployment: #{response.class} -- #{response.body || 'no response'}"
-        return false
-      end
-    end
-  end
-end
-

data/lib/rails/generators/honeybadger/honeybadger_generator.rb

@@ -1,99 +0,0 @@
-require 'rails/generators'
-
-class HoneybadgerGenerator < Rails::Generators::Base
-  class_option :api_key, :aliases => "-k", :type => :string, :desc => "Your Honeybadger API key"
-  class_option :heroku, :type => :boolean, :desc => "Use the Heroku addon to provide your Honeybadger API key"
-  class_option :app, :aliases => "-a", :type => :string, :desc => "Your Heroku app name (only required if deploying to >1 Heroku app)"
-
-  def self.source_root
-    @_honeybadger_source_root ||= File.expand_path("../../../../../generators/honeybadger/templates", __FILE__)
-  end
-
-  def install
-    ensure_api_key_was_configured
-    ensure_plugin_is_not_present
-    append_capistrano_hook
-    generate_initializer unless api_key_configured?
-    determine_api_key if heroku?
-    test_honeybadger
-  end
-
-  private
-
-  def ensure_api_key_was_configured
-    if !options[:api_key] && !options[:heroku] && !api_key_configured?
-      puts "Must pass --api-key or --heroku or create config/initializers/honeybadger.rb"
-      exit
-    end
-  end
-
-  def ensure_plugin_is_not_present
-    if plugin_is_present?
-      puts "You must first remove the honeybadger plugin. Please run: script/plugin remove honeybadger"
-      exit
-    end
-  end
-
-  def append_capistrano_hook
-    if File.exists?('config/deploy.rb') && File.exists?('Capfile')
-      append_file('Capfile', <<-HOOK)
-
-        require 'honeybadger/capistrano'
-      HOOK
-    end
-  end
-
-  def api_key_expression
-    s = if options[:api_key]
-          "'#{options[:api_key]}'"
-        elsif options[:heroku]
-          "ENV['HONEYBADGER_API_KEY']"
-        end
-  end
-
-  def generate_initializer
-    template 'initializer.rb', 'config/initializers/honeybadger.rb'
-  end
-
-  def determine_api_key
-    puts "Attempting to determine your API Key from Heroku..."
-    ENV['HONEYBADGER_API_KEY'] = heroku_api_key
-    if ENV['HONEYBADGER_API_KEY'] =~ /\S/
-      puts "... Done."
-      puts "Heroku's Honeybadger API Key is '#{ENV['HONEYBADGER_API_KEY']}'"
-    else
-      puts "... Failed."
-      puts "WARNING: We were unable to detect the Honeybadger API Key from your Heroku environment."
-      puts "Your Heroku application environment may not be configured correctly."
-      puts "Have you configured multiple Heroku apps? Try using the '--app [app name]' flag." unless options[:app]
-      exit 1
-    end
-  end
-
-  def heroku_var(var, app_name = nil)
-    app = app_name ? "--app #{app_name}" : ''
-    Bundler.with_clean_env { `heroku config:get #{var} #{app}` }
-  end
-
-  def heroku_api_key
-    heroku_var("HONEYBADGER_API_KEY", options[:app]).split.find {|x| x =~ /\S/ }
-  end
-
-  def heroku?
-    options[:heroku] ||
-      system("grep HONEYBADGER_API_KEY config/initializers/honeybadger.rb") ||
-      system("grep HONEYBADGER_API_KEY config/environment.rb")
-  end
-
-  def api_key_configured?
-    File.exists?('config/initializers/honeybadger.rb')
-  end
-
-  def test_honeybadger
-    puts run("rake honeybadger:test --trace")
-  end
-
-  def plugin_is_present?
-    File.exists?('vendor/plugins/honeybadger')
-  end
-end

data/rails/init.rb

@@ -1 +0,0 @@
-require 'honeybadger/rails'

data/resources/README.md

@@ -1,34 +0,0 @@
-Honeybadger Resources
-==================
-
-Honeybadger has an SSL mode available to paying plans. SSL Certificate Authority (CA) certificates are not kept current by default on many environments. When CA certs are stale, Honeybadger cannot verify Honeybadger's production SSL cert and error reports fail. To avoid this, we now package local CA certs. The production of these certs is detailed here.
-
-Building ca-bundle.crt
-----------------------
-
-From https://gist.github.com/996292.
-
-If you want to use curl or net-http/open-uri to access https resources, you will often (always?) get an error, because they don't have the large number of root certificates installed that web browsers have.
-
-You can manually install the root certs, but first you have to get them from somewhere. [This article](http://notetoself.vrensk.com/2008/09/verified-https-in-ruby/) gives a nice description of how to do that. The [source of the cert files](http://curl.haxx.se/ca/cacert.pem) it points to is hosted by the curl project, who kindly provide it in the .pem format.
-
-**problem:** Sadly, ironically, and comically, it's not possible to access that file via https! Luckily, the awesome curl project does provide us with the script that they use to produce the file, so we can do it securely ourselves. Here's how.
-
-1. `git clone https://github.com/bagder/curl.git`
-2. `cd curl/lib`
-3. edit `mk-ca-bundle.pl` and change:
-
-    ```perl
-    my $url = 'http://mxr.mozilla.org/mozilla/source/security/nss/lib/ckfw/builtins/certdata.txt?raw=1';
-    ```
-
-    to
-
-    ```perl
-    my $url = 'https://mxr.mozilla.org/mozilla/source/security/nss/lib/ckfw/builtins/certdata.txt?raw=1';
-    ```
-
-    (change `http` to `https`)
-4. `./mk-ca-bundle.pl`
-
-Ta da!

data/script/integration_test.rb

@@ -1,38 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'logger'
-require 'fileutils'
-
-RAILS_ENV = "production"
-RAILS_ROOT = FileUtils.pwd
-RAILS_DEFAULT_LOGGER = Logger.new(STDOUT)
-
-$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'honeybadger'
-require 'rails/init'
-
-fail "Please supply an API Key as the first argument" if ARGV.empty?
-
-host = ARGV[1]
-host ||= "api.honeybadger.io"
-
-secure = (ARGV[2] == "secure")
-
-exception = begin
-              raise "Testing honeybadger notifier with secure = #{secure}. If you can see this, it works."
-            rescue => foo
-              foo
-            end
-
-Honeybadger.configure do |config|
-  config.secure  = secure
-  config.host    = host
-  config.api_key = ARGV.first
-end
-puts "Configuration:"
-Honeybadger.configuration.to_hash.each do |key, value|
-  puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
-end
-puts "Sending #{secure ? "" : "in"}secure notification to project with key #{ARGV.first}"
-Honeybadger.notify(exception)
-

data/spec/allocation_stats.rb

@@ -1,32 +0,0 @@
-require 'allocation_stats'
-require 'honeybadger'
-require 'benchmark'
-require 'sham_rack'
-
-ShamRack.at('api.honeybadger.io', 443).stub.tap do |app|
-  app.register_resource('/v1/notices/', %({"id":"123456789"}), "application/json")
-  app.register_resource('/v1/ping/', %({"features":{"notices":true,"feedback":true}, "limit":null}), "application/json")
-end
-
-group_by = if ENV['GROUP']
-             ENV['GROUP'].split(',').lazy.map(&:strip).map(&:to_sym).freeze
-           else
-             [:sourcefile, :sourceline, :class].freeze
-           end
-
-puts Benchmark.measure {
-  stats = AllocationStats.trace do
-    Honeybadger.configure do |config|
-      config.api_key = 'badgers'
-      config.environment_name = 'production'
-      config.development_environments = []
-    end
-
-    1000.times do
-      Honeybadger.notify(error_class: 'AllocationStats', error_message: 'Profiling Honeybadger -- this should never actually be reported.')
-    end
-  end
-
-  puts stats.allocations(alias_paths: true).group_by(*group_by).to_text
-  puts "\n\n"
-}

data/spec/honeybadger/backtrace_spec.rb

@@ -1,242 +0,0 @@
-require 'spec_helper'
-require 'stringio'
-
-describe Honeybadger::Backtrace do
-  it "parses a backtrace into lines" do
-    array = [
-      "app/models/user.rb:13:in `magic'",
-      "app/controllers/users_controller.rb:8:in `index'"
-    ]
-
-    backtrace = Honeybadger::Backtrace.parse(array)
-
-    line = backtrace.lines.first
-    expect(line.number).to eq '13'
-    expect(line.file).to eq 'app/models/user.rb'
-    expect(line.method).to eq 'magic'
-
-    line = backtrace.lines.last
-    expect(line.number).to eq '8'
-    expect(line.file).to eq 'app/controllers/users_controller.rb'
-    expect(line.method).to eq 'index'
-  end
-
-  it "parses a windows backtrace into lines" do
-    array = [
-      "C:/Program Files/Server/app/models/user.rb:13:in `magic'",
-      "C:/Program Files/Server/app/controllers/users_controller.rb:8:in `index'"
-    ]
-
-    backtrace = Honeybadger::Backtrace.parse(array)
-
-    line = backtrace.lines.first
-    expect(line.number).to eq '13'
-    expect(line.file).to eq 'C:/Program Files/Server/app/models/user.rb'
-    expect(line.method).to eq 'magic'
-
-    line = backtrace.lines.last
-    expect(line.number).to eq '8'
-    expect(line.file).to eq 'C:/Program Files/Server/app/controllers/users_controller.rb'
-    expect(line.method).to eq 'index'
-  end
-
-  it "is equal with equal lines" do
-    one = build_backtrace_array
-    two = one.dup
-
-    expect(Honeybadger::Backtrace.parse(one)).to eq Honeybadger::Backtrace.parse(two)
-  end
-
-  it "parses massive one-line exceptions into multiple lines" do
-    original_backtrace = Honeybadger::Backtrace.
-      parse(["one:1:in `one'\n   two:2:in `two'\n      three:3:in `three`"])
-    expected_backtrace = Honeybadger::Backtrace.
-      parse(["one:1:in `one'", "two:2:in `two'", "three:3:in `three`"])
-
-    expect(expected_backtrace).to eq original_backtrace
-  end
-
-  context "when source file exists" do
-    before(:each) do
-      source = <<-RUBY
-        $:<<'lib'
-        require 'honeybadger'
-
-        begin
-          raise StandardError
-        rescue => e
-          puts Honeybadger::Notice.new(exception: e).backtrace.to_json
-        end
-      RUBY
-
-      array = [
-        "app/models/user.rb:2:in `magic'",
-        "app/concerns/authenticated_controller.rb:4:in `authorize'",
-        "app/controllers/users_controller.rb:8:in `index'"
-      ]
-
-      ['app/models/user.rb', 'app/concerns/authenticated_controller.rb', 'app/controllers/users_controller.rb'].each do |file|
-        File.should_receive(:exists?).with(file).and_return true
-        File.should_receive(:open).with(file).and_yield StringIO.new(source)
-      end
-
-      @backtrace = Honeybadger::Backtrace.parse(array)
-    end
-
-    it "includes a snippet from the source file for each line of the backtrace" do
-      expect(@backtrace.lines[0].source.keys.size).to eq(4)
-      expect(@backtrace.lines[0].source[1]).to match(/\$:<</)
-      expect(@backtrace.lines[0].source[2]).to match(/require/)
-      expect(@backtrace.lines[0].source[3]).to match(/\n/)
-      expect(@backtrace.lines[0].source[4]).to match(/begin/)
-
-      expect(@backtrace.lines[1].source.keys.size).to eq(5)
-      expect(@backtrace.lines[1].source[2]).to match(/require/)
-      expect(@backtrace.lines[1].source[3]).to match(/\n/)
-      expect(@backtrace.lines[1].source[4]).to match(/begin/)
-      expect(@backtrace.lines[1].source[5]).to match(/StandardError/)
-      expect(@backtrace.lines[1].source[6]).to match(/rescue/)
-
-      expect(@backtrace.lines[2].source.keys.size).to eq(3)
-      expect(@backtrace.lines[2].source[6]).to match(/rescue/)
-      expect(@backtrace.lines[2].source[7]).to match(/Honeybadger/)
-      expect(@backtrace.lines[2].source[8]).to match(/end/)
-    end
-  end
-
-  it "fails gracefully when looking up snippet and file doesn't exist" do
-    array = [
-      "app/models/user.rb:13:in `magic'",
-      "app/controllers/users_controller.rb:8:in `index'"
-    ]
-
-    backtrace = Honeybadger::Backtrace.parse(array)
-
-    expect(backtrace.lines[0].source).to be_empty
-    expect(backtrace.lines[1].source).to be_empty
-  end
-
-  it "has an empty application trace by default" do
-    backtrace = Honeybadger::Backtrace.parse(build_backtrace_array)
-    expect(backtrace.application_lines).to be_empty
-  end
-
-  context "with a project root" do
-    before(:each) do
-      @project_root = '/some/path'
-      Honeybadger.configure {|config| config.project_root = @project_root }
-
-      @backtrace_with_root = Honeybadger::Backtrace.parse(
-        ["#{@project_root}/app/models/user.rb:7:in `latest'",
-         "#{@project_root}/app/controllers/users_controller.rb:13:in `index'",
-         "#{@project_root}/vendor/plugins/foo/bar.rb:42:in `baz'",
-         "/lib/something.rb:41:in `open'"],
-         :filters => default_filters)
-      @backtrace_without_root = Honeybadger::Backtrace.parse(
-        ["[PROJECT_ROOT]/app/models/user.rb:7:in `latest'",
-         "[PROJECT_ROOT]/app/controllers/users_controller.rb:13:in `index'",
-         "[PROJECT_ROOT]/vendor/plugins/foo/bar.rb:42:in `baz'",
-         "/lib/something.rb:41:in `open'"])
-    end
-
-    it "filters out the project root" do
-      expect(@backtrace_without_root).to eq @backtrace_with_root
-    end
-
-    it "has an application trace" do
-      expect(@backtrace_without_root.application_lines).to eq @backtrace_without_root.lines[0..1]
-    end
-
-    it "filters ./vendor from application trace" do
-      expect(@backtrace_without_root.application_lines).not_to include(@backtrace_without_root.lines[2])
-    end
-  end
-
-  context "with a project root equals to a part of file name" do
-    before(:each) do
-      # Heroku-like
-      @project_root = '/app'
-      Honeybadger.configure {|config| config.project_root = @project_root }
-    end
-
-    it "filters out the project root" do
-      backtrace_with_root = Honeybadger::Backtrace.parse(
-        ["#{@project_root}/app/models/user.rb:7:in `latest'",
-         "#{@project_root}/app/controllers/users_controller.rb:13:in `index'",
-         "/lib/something.rb:41:in `open'"],
-         :filters => default_filters)
-         backtrace_without_root = Honeybadger::Backtrace.parse(
-           ["[PROJECT_ROOT]/app/models/user.rb:7:in `latest'",
-            "[PROJECT_ROOT]/app/controllers/users_controller.rb:13:in `index'",
-            "/lib/something.rb:41:in `open'"])
-
-         expect(backtrace_without_root).to eq backtrace_with_root
-    end
-  end
-
-  context "with a blank project root" do
-    before(:each) do
-      Honeybadger.configure {|config| config.project_root = '' }
-    end
-
-    it "does not filter line numbers with respect to any project root" do
-      backtrace = ["/app/models/user.rb:7:in `latest'",
-                   "/app/controllers/users_controller.rb:13:in `index'",
-                   "/lib/something.rb:41:in `open'"]
-
-      backtrace_with_root =
-        Honeybadger::Backtrace.parse(backtrace, :filters => default_filters)
-
-      backtrace_without_root =
-        Honeybadger::Backtrace.parse(backtrace)
-
-      expect(backtrace_without_root).to eq backtrace_with_root
-    end
-  end
-
-  it "removes notifier trace" do
-    inside_notifier  = ['lib/honeybadger.rb:13:in `voodoo`']
-    outside_notifier = ['users_controller:8:in `index`']
-
-    without_inside = Honeybadger::Backtrace.parse(outside_notifier)
-    with_inside    = Honeybadger::Backtrace.parse(inside_notifier + outside_notifier,
-                                                  :filters => default_filters)
-
-    expect(without_inside).to eq with_inside
-  end
-
-  it "runs filters on the backtrace" do
-    filters = [lambda { |line| line.sub('foo', 'bar') }]
-    input = Honeybadger::Backtrace.parse(["foo:13:in `one'", "baz:14:in `two'"],
-                                         :filters => filters)
-    expected = Honeybadger::Backtrace.parse(["bar:13:in `one'", "baz:14:in `two'"])
-    expect(expected).to eq input
-  end
-
-  it "aliases #to_ary as #to_a" do
-    backtrace = Honeybadger::Backtrace.parse(build_backtrace_array)
-
-    expect(backtrace.to_a).to eq backtrace.to_ary
-  end
-
-  it "generates json from to_array template" do
-    backtrace = Honeybadger::Backtrace.parse(build_backtrace_array)
-    array = [{'foo' => 'bar'}]
-    backtrace.should_receive(:to_ary).once.and_return(array)
-    json = backtrace.to_json
-
-    payload = nil
-    expect { payload = JSON.parse(json) }.not_to raise_error
-
-    expect(payload).to eq array
-  end
-
-  def build_backtrace_array
-    ["app/models/user.rb:13:in `magic'",
-     "app/controllers/users_controller.rb:8:in `index'"]
-  end
-
-  def default_filters
-    Honeybadger::Configuration::DEFAULT_BACKTRACE_FILTERS
-  end
-end