airbrake 4.3.8 → 5.0.0

data/lib/airbrake.rb

@@ -1,191 +1,22 @@
-begin
-  require "girl_friday"
-rescue LoadError
-end
-
-begin
-  require "sucker_punch"
-rescue LoadError
-end
+# For 'Socket.gethostname' only.
+require 'socket'
 
-require 'net/http'
-require 'net/https'
-require 'rubygems'
-require 'logger'
+# Core library that sends notices.
+# See: https://github.com/airbrake/airbrake-ruby
+require 'airbrake-ruby'
 
 require 'airbrake/version'
-require 'airbrake/jobs/send_job'
-require 'airbrake/utils/rack_filters'
-require 'airbrake/utils/params_cleaner'
-require 'airbrake/configuration'
-require 'airbrake/notice'
-require 'airbrake/sender'
-require 'airbrake/response'
-require 'airbrake/backtrace'
-require 'airbrake/rack'
-require 'airbrake/sinatra'
-require 'airbrake/user_informer'
-
-begin
-  require 'airbrake/sidekiq'
-rescue LoadError
-end
-
-require 'airbrake/railtie' if defined?(Rails::Railtie)
-
-module Airbrake
-  API_VERSION = "2.4"
-  LOG_PREFIX = "** [Airbrake] "
-
-  class << self
-    # The sender object is responsible for delivering formatted data to the Airbrake server.
-    # Must respond to #send_to_airbrake. See Airbrake::Sender.
-    attr_accessor :sender
-
-    # A Airbrake configuration object. Must act like a hash and return sensible
-    # values for all Airbrake configuration options. See Airbrake::Configuration.
-    attr_writer :configuration
-
-    # Tell the log that the Notifier is good to go
-    def report_ready
-      write_verbose_log("Notifier #{VERSION} ready to catch errors")
-    end
-
-    # Prints out the environment info to the log for debugging help
-    def report_environment_info
-      write_verbose_log("Environment Info: #{environment_info}")
-    end
-
-    # Prints out the response body from Airbrake for debugging help
-    def report_response_body(response)
-      write_verbose_log("Response from Airbrake: \n#{Response.pretty_format(response)}")
-    end
-
-    # Prints out the details about the notice that wasn't sent to server
-    def report_notice(notice)
-      write_verbose_log("Notice details: \n#{notice}")
-    end
-
-    def report_notice_not_sent_for_configuration
-      write_verbose_log("Notice was not sent due to configuration: \
-        \n  Environment Monitored? #{configuration.public?} \
-        \n  API key set? #{configuration.configured?}")
-    end
-
-    # Returns the Ruby version, Rails version, and current Rails environment
-    def environment_info
-      info = "[Ruby: #{RUBY_VERSION}]"
-      info << " [#{configuration.framework}]" if configuration.framework
-      info << " [Env: #{configuration.environment_name}]" if configuration.environment_name
-      info
-    end
 
-    # Writes out the given message to the #logger
-    def write_verbose_log(message)
-      logger.debug LOG_PREFIX + message if logger
-    end
+# Automatically load needed files for the environment the library is running in.
+if defined?(Rack)
+  require 'airbrake/rack/user'
+  require 'airbrake/rack/notice_builder'
+  require 'airbrake/rack/middleware'
 
-    # Look for the Rails logger currently defined
-    def logger
-      self.configuration.logger ||
-        Logger.new(nil)
-    end
-
-    # Call this method to modify defaults in your initializers.
-    #
-    # @example
-    #   Airbrake.configure do |config|
-    #     config.api_key = '1234567890abcdef'
-    #     config.secure  = false
-    #   end
-    def configure(silent = false)
-      yield(configuration)
-      self.sender = if configuration.test_mode?
-                      CollectingSender.new(configuration)
-                    else
-                      Sender.new(configuration)
-                    end
-
-      report_ready unless silent
-      self.sender
-    end
-
-    # The configuration object.
-    # @see Airbrake.configure
-    def configuration
-      @configuration ||= Configuration.new
-    end
-
-    # Sends an exception manually using this method, even when you are not in a controller.
-    #
-    # @param [Exception] exception The exception you want to notify Airbrake about.
-    # @param [Hash] opts Data that will be sent to Airbrake.
-    #
-    # @option opts [String] :api_key The API key for this project. The API key is a unique identifier that Airbrake uses for identification.
-    # @option opts [String] :error_message The error returned by the exception (or the message you want to log).
-    # @option opts [String] :backtrace A backtrace, usually obtained with +caller+.
-    # @option opts [String] :rack_env The Rack environment.
-    # @option opts [String] :session The contents of the user's session.
-    # @option opts [String] :environment_name The application environment name.
-    # @option opts [String] :parameters Additional parameters.
-    def notify(exception, opts = {})
-      send_notice(build_notice_for(exception, opts))
-    end
-
-    # Sends the notice unless it is one of the default ignored exceptions
-    # @see Airbrake.notify
-    def notify_or_ignore(exception, opts = {})
-      notice = build_notice_for(exception, opts)
-      send_notice(notice) unless notice.ignore?
-    end
-
-    def 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 send_notice(notice)
-      if configuration.configured? && configuration.public?
-        if configuration.async?
-          configuration.async.call(notice)
-          nil # make sure we never set env["airbrake.error_id"] for async notices
-        else
-          sender.send_to_airbrake(notice)
-        end
-      else
-        report_notice_not_sent_for_configuration
-      end
-    end
-
-    def build_notice_for(exception, opts = {})
-      exception_classes = [exception.class.to_s]
-      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)
-      opts = opts.merge(:exception_classes => exception_classes)
-      Notice.new(configuration.merge(opts))
-    end
-
-    def unwrap_exception(exception)
-      if exception.respond_to?(:original_exception)
-        exception.original_exception
-      elsif exception.respond_to?(:continued_exception)
-        exception.continued_exception
-      end || exception
-    end
-  end
+  require 'airbrake/rails/railtie' if defined?(Rails)
 end
+
+require 'airbrake/rake/task_ext' if defined?(Rake)
+require 'airbrake/resque/failure' if defined?(Resque)
+require 'airbrake/sidekiq/error_handler' if defined?(Sidekiq)
+require 'airbrake/delayed_job/plugin' if defined?(Delayed)

data/lib/generators/airbrake_generator.rb

@@ -0,0 +1,25 @@
+##
+# Creates the Airbrake initializer file for Rails apps.
+#
+# @example Invokation from terminal
+#   rails generate airbrake PROJECT_KEY PROJECT_ID [NAME]
+#
+class AirbrakeGenerator < Rails::Generators::Base
+  # Adds current directory to source paths, so we can find the template file.
+  source_root File.expand_path('..', __FILE__)
+
+  argument :project_id, required: false
+  argument :project_key, required: false
+
+  ##
+  # Makes the NAME option optional, which allows to subclass from Base, so we
+  # can pass arguments to the ERB template.
+  #
+  # @see http://asciicasts.com/episodes/218-making-generators-in-rails-3
+  argument :name, type: :string, default: 'application'
+
+  desc 'Configures the Airbrake notifier with your project id and project key'
+  def generate_layout
+    template 'airbrake_initializer.rb.erb', 'config/initializers/airbrake.rb'
+  end
+end

data/lib/generators/airbrake_initializer.rb.erb

@@ -0,0 +1,55 @@
+# Airbrake is an online tool that provides robust exception tracking in your Rails
+# applications. In doing so, it allows you to easily review errors, tie an error
+# to an individual piece of code, and trace the cause back to recent
+# changes. Airbrake enables for easy categorization, searching, and prioritization
+# of exceptions so that when errors occur, your team can quickly determine the
+# root cause.
+#
+# Configuration details:
+# https://github.com/airbrake/airbrake-ruby#configuration
+Airbrake.configure do |c|
+  # You must set both project_id & project_key. To find your project_id and
+  # project_key navigate to your project's General Settings and copy the values
+  # from the right sidebar.
+  # https://github.com/airbrake/airbrake-ruby#project_id--project_key
+<% if project_id -%>
+  c.project_id = <%= project_id %>
+<% else -%>
+  c.project_id = ENV['AIRBRAKE_PROJECT_ID']
+<% end -%>
+<% if project_key -%>
+  c.project_key = '<%= project_key %>'
+<% else -%>
+  c.project_key = ENV['AIRBRAKE_API_KEY']
+<% end -%>
+
+  # Configures the root directory of your project. Expects a String or a
+  # Pathname, which represents the path to your project. Providing this option
+  # helps us to filter out repetitive data from backtrace frames and link to
+  # GitHub files from our dashboard.
+  # https://github.com/airbrake/airbrake-ruby#root_directory
+  c.root_directory = Rails.root
+
+  # By default, Airbrake Ruby outputs to STDOUT. In Rails apps it makes sense to
+  # use the Rails' logger.
+  # https://github.com/airbrake/airbrake-ruby#logger
+  c.logger = Rails.logger
+
+  # Configures the environment the application is running in. Helps the Airbrake
+  # dashboard to distinguish between exceptions occurring in different
+  # environments. By default, it's not set.
+  # https://github.com/airbrake/airbrake-ruby#environment
+  c.environment = Rails.env
+
+  # Setting this option allows Airbrake to filter exceptions occurring in
+  # unwanted environments such as :test. By default, it is equal to an empty
+  # Array, which means Airbrake Ruby sends exceptions occurring in all
+  # environments.
+  # https://github.com/airbrake/airbrake-ruby#ignore_environments
+  c.ignore_environments = %w(test)
+end
+
+# If Airbrake doesn't send any expected exceptions, we suggest to uncomment the
+# line below. It might simplify debugging of background Airbrake workers, which
+# can silently die.
+# Thread.abort_on_exception = ['test', 'development'].include?(Rails.env)

data/spec/apps/rack/dummy_app.rb

@@ -0,0 +1,17 @@
+DummyApp = Rack::Builder.new do
+  use Rack::ShowExceptions
+  use Airbrake::Rack::Middleware
+  use Warden::Manager
+
+  map '/' do
+    run(
+      proc do |_env|
+        [200, { 'Content-Type' => 'text/plain' }, ['Hello from index']]
+      end
+    )
+  end
+
+  map '/crash' do
+    run proc { |_env| raise AirbrakeTestError }
+  end
+end

data/spec/apps/rails/dummy_app.rb

@@ -0,0 +1,150 @@
+class DummyApp < Rails::Application
+  # Rails requires these two keys.
+  config.session_store :cookie_store, key: 'jiez4Mielu1AiHugog3shiiPhe3lai3faer'
+  config.secret_token = 'ni6aeph6aeriBiphesh8omahv6cohpue5Quah5ceiMohtuvei8'
+
+  if Gem::Version.new(Rails.version) > Gem::Version.new('3.2.0')
+    config.secret_key_base = '62773890cad9d9d584b57320f8612f8f7378a90aadcabc6ee'
+  end
+
+  # Configure a logger, without it the tests can't run.
+  vsn = Rails.version.split('').values_at(0, 2).join('')
+  log_path = File.join(File.dirname(__FILE__), 'logs', "#{vsn}.log")
+  config.logger = Logger.new(log_path)
+  Rails.logger = config.logger
+
+  config.active_support.deprecation = :stderr
+
+  config.middleware.use Warden::Manager
+
+  # In Rails 4.2.x Active Record suppresses errors raised within
+  # 'after_rollback' & 'after_commit' callbacks and only print them to the
+  # logs. In the next version, these errors will no longer be suppressed.
+  # Instead, the errors will propagate normally just like in other Active Record
+  # callbacks.
+  config.active_record.raise_in_transactional_callbacks = true if vsn == '42'
+
+  # Silences the warning, which says 'config.eager_load is set to nil'.
+  config.eager_load = false
+
+  routes.append do
+    get '/' => 'dummy#index'
+    get '/crash' => 'dummy#crash'
+    get '/notify_airbrake_helper' => 'dummy#notify_airbrake_helper'
+    get '/notify_airbrake_sync_helper' => 'dummy#notify_airbrake_sync_helper'
+    get '/active_record_after_commit' => 'dummy#active_record_after_commit'
+    get '/active_record_after_rollback' => 'dummy#active_record_after_rollback'
+    get '/active_job' => 'dummy#active_job'
+    get '/resque' => 'dummy#resque'
+    get '/delayed_job' => 'dummy#delayed_job'
+  end
+end
+
+class Book < ActiveRecord::Base
+  after_commit :raise_error_after_commit
+  after_rollback :raise_error_after_rollback
+
+  def raise_error_after_commit
+    raise AirbrakeTestError, 'after_commit'
+  end
+
+  def raise_error_after_rollback
+    raise AirbrakeTestError, 'after_rollback'
+  end
+end
+
+# ActiveJob.
+if Gem::Version.new(Rails.version) >= Gem::Version.new('4.2')
+  class BingoJob < ActiveJob::Base
+    queue_as :bingo
+
+    def perform(*_args)
+      raise AirbrakeTestError, 'active_job error'
+    end
+  end
+end
+
+# Resque.
+class BingoWorker
+  @queue = :bingo_workers_queue
+
+  def self.perform(_bango, _bongo)
+    raise AirbrakeTestError, 'resque error'
+  end
+end
+
+# DelayedJob.
+BangoJob = Struct.new(:bingo, :bongo) do
+  def perform
+    raise AirbrakeTestError, 'delayed_job error'
+  end
+end
+
+class DummyController < ActionController::Base
+  layout 'application'
+
+  self.view_paths = [
+    ActionView::FixtureResolver.new(
+      'layouts/application.html.erb' => '<%= yield %>',
+      'dummy/index.html.erb' => 'Hello from index',
+      'dummy/notify_airbrake_helper.html.erb' => 'notify_airbrake_helper',
+      'dummy/notify_airbrake_sync_helper.html.erb' => 'notify_airbrake_helper_sync',
+      'dummy/active_record_after_commit.html.erb' => 'active_record_after_commit',
+      'dummy/active_record_after_rollback.html.erb' => 'active_record_after_rollback',
+      'dummy/active_job.html.erb' => 'active_job',
+      'dummy/resque.html.erb' => 'resque',
+      'dummy/delayed_job.html.erb' => 'delayed_job'
+    )
+  ]
+
+  def index
+  end
+
+  def crash
+    raise AirbrakeTestError
+  end
+
+  def notify_airbrake_helper
+    notify_airbrake(AirbrakeTestError.new)
+  end
+
+  def notify_airbrake_sync_helper
+    notify_airbrake_sync(AirbrakeTestError.new)
+  end
+
+  def active_record_after_commit
+    Book.create(title: 'Bingo')
+  end
+
+  def active_record_after_rollback
+    Book.transaction do
+      Book.create(title: 'Bango')
+      raise ActiveRecord::Rollback
+    end
+  end
+
+  def active_job
+    BingoJob.perform_later('bango', 'bongo')
+  end
+
+  def resque
+    Resque.enqueue(BingoWorker, 'bango', 'bongo')
+  end
+
+  def delayed_job
+    Delayed::Job.enqueue(BangoJob.new('bingo', 'bongo'))
+  end
+end
+
+# Initializes middlewares and such.
+DummyApp.initialize!
+
+ActiveRecord::Base.connection.create_table(:books) do |t|
+  t.string(:title)
+end
+
+ActiveRecord::Migration.verbose = false
+require 'generators/delayed_job/templates/migration'
+ActiveRecord::Schema.define do
+  CreateDelayedJobs.up
+end

data/spec/apps/rails/dummy_task.rake

@@ -0,0 +1,20 @@
+# Keep this before any task definitions to collect extra info about tasks.
+# Without this line the tests will fail.
+Rake::TaskManager.record_task_metadata = true
+
+namespace :bingo do
+  # This task contains *maximum* amount of information.
+  desc 'Dummy description'
+  task :bango, [:dummy_arg] => [:environment] do |_t, _args|
+    raise AirbrakeTestError
+  end
+
+  # This task contains *minimum* amount of information.
+  task :bongo do
+    raise AirbrakeTestError
+  end
+
+  task :environment do
+    # No-op.
+  end
+end