honeybadger 1.0.0

data/generators/honeybadger/lib/insert_commands.rb

@@ -0,0 +1,34 @@
+# Mostly pinched from http://github.com/ryanb/nifty-generators/tree/master
+
+Rails::Generator::Commands::Base.class_eval do
+  def file_contains?(relative_destination, line)
+    File.read(destination_path(relative_destination)).include?(line)
+  end
+end
+
+Rails::Generator::Commands::Create.class_eval do
+  def append_to(file, line)
+    logger.insert "#{line} appended to #{file}"
+    unless options[:pretend] || file_contains?(file, line)
+      File.open(file, "a") do |file|
+        file.puts
+        file.puts line
+      end
+    end
+  end
+end
+
+Rails::Generator::Commands::Destroy.class_eval do
+  def append_to(file, line)
+    logger.remove "#{line} removed from #{file}"
+    unless options[:pretend]
+      gsub_file file, "\n#{line}", ''
+    end
+  end
+end
+
+Rails::Generator::Commands::List.class_eval do
+  def append_to(file, line)
+    logger.insert "#{line} appended to #{file}"
+  end
+end

data/generators/honeybadger/lib/rake_commands.rb

@@ -0,0 +1,24 @@
+Rails::Generator::Commands::Create.class_eval do
+  def rake(cmd, opts = {})
+    logger.rake "rake #{cmd}"
+    unless system("rake #{cmd}")
+      logger.rake "#{cmd} failed. Rolling back"
+      command(:destroy).invoke!
+    end
+  end
+end
+
+Rails::Generator::Commands::Destroy.class_eval do
+  def rake(cmd, opts = {})
+    unless opts[:generate_only]
+      logger.rake "rake #{cmd}"
+      system "rake #{cmd}"
+    end
+  end
+end
+
+Rails::Generator::Commands::List.class_eval do
+  def rake(cmd, opts = {})
+    logger.rake "rake #{cmd}"
+  end
+end

data/generators/honeybadger/templates/capistrano_hook.rb

@@ -0,0 +1,6 @@
+
+Dir[File.join(File.dirname(__FILE__), '..', 'vendor', 'gems', 'honeybadger-*')].each do |vendored_notifier|
+  $: << File.join(vendored_notifier, 'lib')
+end
+
+require 'honeybadger/capistrano'

data/generators/honeybadger/templates/honeybadger_tasks.rake

@@ -0,0 +1,25 @@
+# Don't load anything when running the gems:* tasks.
+# Otherwise, honeybadger will be considered a framework gem.
+# https://thoughtbot.lighthouseapp.com/projects/14221/tickets/629
+unless ARGV.any? {|a| a =~ /^gems/} 
+
+  Dir[File.join(Rails.root, 'vendor', 'gems', 'honeybadger-*')].each do |vendored_notifier|
+    $: << File.join(vendored_notifier, 'lib')
+  end
+
+  begin
+    require 'honeybadger/tasks'
+  rescue LoadError => exception
+    namespace :honeybadger do
+      %w(deploy test log_stdout).each do |task_name|
+        desc "Missing dependency for honeybadger:#{task_name}"
+        task task_name do
+          $stderr.puts "Failed to run honeybadger:#{task_name} because of missing dependency."
+          $stderr.puts "You probably need to run `rake gems:install` to install the honeybadger gem"
+          abort exception.inspect
+        end
+      end
+    end
+  end
+
+end

data/generators/honeybadger/templates/initializer.rb

@@ -0,0 +1,6 @@
+<% if Rails::VERSION::MAJOR < 3 && Rails::VERSION::MINOR < 2 -%>
+require 'honeybadger/rails'
+<% end -%>
+Honeybadger.configure do |config|
+  config.api_key = <%= api_key_expression %>
+end

data/honeybadger.gemspec

@@ -0,0 +1,109 @@
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = '1.3.5'
+
+  s.name              = 'honeybadger'
+  s.version           = '1.0.0'
+  s.date              = '2012-06-27'
+
+  s.summary     = "Error reports you can be happy about."
+  s.description = "Make managing application errors a more pleasant experience."
+
+  s.authors  = ["Joshua Wood"]
+  s.email    = 'josh@honeybadger.io'
+  s.homepage = 'http://www.honeybadger.io'
+
+  s.require_paths = %w[lib]
+
+  s.rdoc_options = ["--charset=UTF-8", "--markup tomdoc"]
+  s.extra_rdoc_files = %w[README.md MIT-LICENSE]
+
+  s.add_dependency("json")
+  s.add_dependency("activesupport")
+
+  s.add_development_dependency("actionpack",        "~> 2.3.8")
+  s.add_development_dependency("activerecord",      "~> 2.3.8")
+  s.add_development_dependency("activesupport",     "~> 2.3.8")
+  s.add_development_dependency("bourne",            ">= 1.0")
+  s.add_development_dependency("cucumber",          "~> 0.10.6")
+  s.add_development_dependency("rspec",             "~> 2.6.0")
+  s.add_development_dependency("fakeweb",           "~> 1.3.0")
+  s.add_development_dependency("sham_rack",         "~> 1.3.0")
+  s.add_development_dependency("shoulda",           "~> 2.11.3")
+  s.add_development_dependency("capistrano",        "~> 2.8.0")
+
+  ## Leave this section as-is. It will be automatically generated from the
+  ## contents of your Git repository via the gemspec task. DO NOT REMOVE
+  ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
+  # = MANIFEST =
+  s.files = %w[
+    Gemfile
+    Gemfile.lock
+    Guardfile
+    MIT-LICENSE
+    README.md
+    Rakefile
+    SUPPORTED_RAILS_VERSIONS
+    TESTING.md
+    features/metal.feature
+    features/rack.feature
+    features/rails.feature
+    features/rake.feature
+    features/sinatra.feature
+    features/step_definitions/file_steps.rb
+    features/step_definitions/metal_steps.rb
+    features/step_definitions/rack_steps.rb
+    features/step_definitions/rails_application_steps.rb
+    features/step_definitions/rake_steps.rb
+    features/support/env.rb
+    features/support/honeybadger_shim.rb.template
+    features/support/rails.rb
+    features/support/rake/Rakefile
+    features/support/terminal.rb
+    generators/honeybadger/honeybadger_generator.rb
+    generators/honeybadger/lib/insert_commands.rb
+    generators/honeybadger/lib/rake_commands.rb
+    generators/honeybadger/templates/capistrano_hook.rb
+    generators/honeybadger/templates/honeybadger_tasks.rake
+    generators/honeybadger/templates/initializer.rb
+    honeybadger.gemspec
+    lib/honeybadger.rb
+    lib/honeybadger/backtrace.rb
+    lib/honeybadger/capistrano.rb
+    lib/honeybadger/configuration.rb
+    lib/honeybadger/notice.rb
+    lib/honeybadger/rack.rb
+    lib/honeybadger/rails.rb
+    lib/honeybadger/rails/action_controller_catcher.rb
+    lib/honeybadger/rails/controller_methods.rb
+    lib/honeybadger/rails/middleware/exceptions_catcher.rb
+    lib/honeybadger/rails3_tasks.rb
+    lib/honeybadger/railtie.rb
+    lib/honeybadger/rake_handler.rb
+    lib/honeybadger/sender.rb
+    lib/honeybadger/shared_tasks.rb
+    lib/honeybadger/tasks.rb
+    lib/honeybadger_tasks.rb
+    lib/rails/generators/honeybadger/honeybadger_generator.rb
+    rails/init.rb
+    resources/README.md
+    resources/ca-bundle.crt
+    script/integration_test.rb
+    test/test_helper.rb
+    test/unit/backtrace_test.rb
+    test/unit/capistrano_test.rb
+    test/unit/configuration_test.rb
+    test/unit/honeybadger_tasks_test.rb
+    test/unit/logger_test.rb
+    test/unit/notice_test.rb
+    test/unit/notifier_test.rb
+    test/unit/rack_test.rb
+    test/unit/rails/action_controller_catcher_test.rb
+    test/unit/rails_test.rb
+    test/unit/sender_test.rb
+  ]
+  # = MANIFEST =
+
+  s.test_files = s.files.select { |path| path =~ /^test\/.*_test\.rb/ }
+end

data/lib/honeybadger.rb

@@ -0,0 +1,162 @@
+require 'net/http'
+require 'net/https'
+require 'json'
+
+begin
+  require 'active_support'
+  require 'active_support/core_ext'
+rescue LoadError
+  require 'activesupport'
+  require 'activesupport/core_ext'
+end
+
+require 'honeybadger/configuration'
+require 'honeybadger/backtrace'
+require 'honeybadger/notice'
+require 'honeybadger/rack'
+require 'honeybadger/sender'
+
+require 'honeybadger/railtie' if defined?(Rails::Railtie)
+
+module Honeybadger
+  VERSION = '0.0.1'
+  LOG_PREFIX = "** [Honeybadger] "
+
+  HEADERS = {
+    'Content-type'             => 'application/json',
+    'Accept'                   => 'text/json, application/json'
+  }
+
+  class << self
+    # The sender object is responsible for delivering formatted data to the
+    # Honeybadger server. Must respond to #send_to_honeybadger. See Honeybadger::Sender.
+    attr_accessor :sender
+
+    # A Honeybadger configuration object. Must act like a hash and return sensible
+    # values for all Honeybadger configuration options. See Honeybadger::Configuration.
+    attr_writer :configuration
+  end
+
+  # Tell the log that the Notifier is good to go
+  def self.report_ready
+    write_verbose_log("Notifier #{VERSION} ready to catch errors")
+  end
+
+  # Prints out the environment info to the log for debugging help
+  def self.report_environment_info
+    write_verbose_log("Environment Info: #{environment_info}")
+  end
+
+  # Prints out the response body from Honeybadger for debugging help
+  def self.report_response_body(response)
+    write_verbose_log("Response from Honeybadger: \n#{response}")
+  end
+
+  # Returns the Ruby version, Rails version, and current Rails environment
+  def self.environment_info
+    info = "[Ruby: #{RUBY_VERSION}]"
+    info << " [#{configuration.framework}]" if configuration.framework
+    info << " [Env: #{configuration.environment_name}]" if configuration.environment_name
+  end
+
+  # Writes out the given message to the #logger
+  def self.write_verbose_log(message)
+    logger.info LOG_PREFIX + message if logger
+  end
+
+  # Look for the Rails logger currently defined
+  def self.logger
+    self.configuration.logger
+  end
+
+  # Public: Call this method to modify defaults in your initializers.
+  #
+  # Examples:
+  #
+  #   Honeybadger.configure do |config|
+  #     config.api_key = '1234567890abcdef'
+  #     config.secure  = false
+  #   end
+  #
+  # Yields Honeybadger configuration
+  def self.configure(silent = false)
+    yield(configuration)
+    self.sender = Sender.new(configuration)
+    report_ready unless silent
+    self.sender
+  end
+
+  # Public: The configuration object.
+  # See Honeybadger.configure
+  #
+  # Returns Honeybadger configuration
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Public: Sends an exception manually using this method, even when you are not in a controller.
+  #
+  # exception - The exception you want to notify Honeybadger about.
+  # options   - Data that will be sent to Honeybadger.
+  #             :api_key          - The API key for this project. The API key is a unique identifier
+  #                                 that Honeybadger uses for identification.
+  #             :error_message    - The error returned by the exception (or the message you want to log).
+  #             :backtrace        - A backtrace, usually obtained with +caller+.
+  #             :rack_env         - The Rack environment.
+  #             :session          - The contents of the user's session.
+  #             :environment_name - The application environment name.
+  #
+  # Returns exception ID from Honeybadger on success, false on failure
+  def self.notify(exception, options = {})
+    send_notice(build_notice_for(exception, options))
+  end
+
+  # Public: Sends the notice unless it is one of the default ignored exceptions
+  # see Honeybadger.notify
+  def self.notify_or_ignore(exception, opts = {})
+    notice = build_notice_for(exception, opts)
+    send_notice(notice) unless notice.ignore?
+  end
+
+  def self.build_lookup_hash_for(exception, options = {})
+    notice = build_notice_for(exception, options)
+
+    result = {}
+    result[:action]           = notice.action      rescue nil
+    result[:component]        = notice.component   rescue nil
+    result[:error_class]      = notice.error_class if notice.error_class
+    result[:environment_name] = 'production'
+
+    unless notice.backtrace.lines.empty?
+      result[:file]        = notice.backtrace.lines.first.file
+      result[:line_number] = notice.backtrace.lines.first.number
+    end
+
+    result
+  end
+
+  private
+
+  def self.send_notice(notice)
+    if configuration.public?
+      sender.send_to_honeybadger(notice.to_json)
+    end
+  end
+
+  def self.build_notice_for(exception, opts = {})
+    exception = unwrap_exception(exception)
+    opts = opts.merge(:exception => exception) if exception.is_a?(Exception)
+    opts = opts.merge(exception.to_hash) if exception.respond_to?(:to_hash)
+    Notice.new(configuration.merge(opts))
+  end
+
+  def self.unwrap_exception(exception)
+    if exception.respond_to?(:original_exception)
+      exception.original_exception
+    elsif exception.respond_to?(:continued_exception)
+      exception.continued_exception
+    else
+      exception
+    end
+  end
+end

data/lib/honeybadger/backtrace.rb

@@ -0,0 +1,123 @@
+module Honeybadger
+  # Public: Front end to parsing the backtrace for each notice
+  class Backtrace
+
+    # Public: Handles backtrace parsing line by line
+    class Line
+      # regexp (optionnally allowing leading X: for windows support)
+      INPUT_FORMAT = %r{^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$}.freeze
+
+      # Public: The file portion of the line (such as app/models/user.rb)
+      attr_reader :file
+
+      # Public: The line number portion of the line
+      attr_reader :number
+
+      # Public: The method of the line (such as index)
+      attr_reader :method
+
+      # Public: Parses a single line of a given backtrace
+      #
+      # unparsed_line - The raw line from +caller+ or some backtrace
+      #
+      # Returns the parsed backtrace line
+      def self.parse(unparsed_line)
+        _, file, number, method = unparsed_line.match(INPUT_FORMAT).to_a
+        new(file, number, method)
+      end
+
+      def initialize(file, number, method)
+        self.file   = file
+        self.number = number
+        self.method = method
+      end
+
+      # Public: Reconstructs the line in a readable fashion
+      def to_s
+        "#{file}:#{number}:in `#{method}'"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      def inspect
+        "<Line:#{to_s}>"
+      end
+
+      private
+
+      attr_writer :file, :number, :method
+    end
+
+    # Public: holder for an Array of Backtrace::Line instances
+    attr_reader :lines
+
+    def self.parse(ruby_backtrace, opts = {})
+      ruby_lines = split_multiline_backtrace(ruby_backtrace)
+
+      filters = opts[:filters] || []
+      filtered_lines = ruby_lines.to_a.map do |line|
+        filters.inject(line) do |line, proc|
+          proc.call(line)
+        end
+      end.compact
+
+      lines = filtered_lines.collect do |unparsed_line|
+        Line.parse(unparsed_line)
+      end
+
+      instance = new(lines)
+    end
+
+    def initialize(lines)
+      self.lines = lines
+    end
+
+    # Public
+    #
+    # Returns array containing backtrace lines
+    def to_ary
+      lines.map { |l| { :number => l.number, :file => l.file, :method => l.method } }
+    end
+    alias :to_a :to_ary
+
+    # Public: JSON support
+    #
+    # Returns JSON representation of backtrace
+    def as_json(options = {})
+      to_ary
+    end
+
+    # Public: Creates JSON
+    #
+    # Returns valid JSON representation of backtrace
+    def to_json(*a)
+      as_json.to_json(*a)
+    end
+
+    def inspect
+      "<Backtrace: " + lines.collect { |line| line.inspect }.join(", ") + ">"
+    end
+
+    def ==(other)
+      if other.respond_to?(:lines)
+        lines == other.lines
+      else
+        false
+      end
+    end
+
+    private
+
+    attr_writer :lines
+
+    def self.split_multiline_backtrace(backtrace)
+      if backtrace.to_a.size == 1
+        backtrace.to_a.first.split(/\n\s*/)
+      else
+        backtrace
+      end
+    end
+  end
+end