airbrake 4.3.8 → 5.0.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a9e654c767701024f31596525a324fd9941a284c
-  data.tar.gz: d8beec9cd6a92be3308a4cb2cf945aaea5150eab
+  metadata.gz: a478d42f9ddbdf9ecb24f4ae1ba6fef0050ad83b
+  data.tar.gz: 567e1a0b5fdea978842f8ba8940abc0efe67783a
 SHA512:
-  metadata.gz: e469080a0f94afeebb3be23db68c551a8ddd864b643436581f9711b7a1546f61977d80b69d9f220c56b6fe0d33e26afcb716a38d4d029ec6a8b2e810b6d52263
-  data.tar.gz: ad08bb1d86cbd84d056bae1e55d261b3b23be3c00712eb094360e99fbfd0e5967bbc0ce2219cc45d3e8477a420bf3d44284c648768b0570b19d39a59b2dca605
+  metadata.gz: 2e02cf763f9b0585ef6eb87cef04b06365e25bd2d0ba56b703e72a79226bad3535db0fb39d5a92ce16d5e68416228b98cab94b78eb32f6ca60c6d1c96232e696
+  data.tar.gz: d653d8f1e75a54392e5a704d78232ce6f198cb5b8433df6183cf405a2474dc0eb634382d6db1f964ea63050ea7a510cb67e25931e2bc5a31128db07169338ecb

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/airbrake/capistrano/tasks.rb

@@ -0,0 +1,64 @@
+require 'shellwords'
+require 'fileutils'
+
+if defined?(Capistrano::VERSION) &&
+   Gem::Version.new(Capistrano::VERSION).release >= Gem::Version.new('3.0.0')
+  namespace :airbrake do
+    desc "Notify Airbrake of the deploy"
+    task :deploy do
+      on roles(:all) do
+        within release_path do
+          with rails_env: fetch(:rails_env, fetch(:stage)) do
+            execute :rake, <<-CMD
+              airbrake:deploy USERNAME=#{Shellwords.shellescape(local_user)} \
+                              ENVIRONMENT=#{fetch(:rails_env, fetch(:stage))} \
+                              REVISION=#{fetch(:current_revision)} \
+                              REPOSITORY=#{fetch(:repo_url)} \
+                              VERSION=#{fetch(:app_version)}
+            CMD
+
+            info 'Notified Airbrake of the deploy'
+          end
+        end
+      end
+    end
+  end
+else
+  module Airbrake
+    ##
+    # The Capistrano v2 integration.
+    module Capistrano
+      # rubocop:disable Metrics/AbcSize
+      def self.load_into(config)
+        config.load do
+          after 'deploy',            'airbrake:deploy'
+          after 'deploy:migrations', 'airbrake:deploy'
+          after 'deploy:cold',       'airbrake:deploy'
+
+          namespace :airbrake do
+            desc "Notify Airbrake of the deploy"
+            task :deploy, except: { no_release: true }, on_error: :continue do
+              FileUtils.cd(config.release_path) do
+                username = Shellwords.shellescape(ENV['USER'] || ENV['USERNAME'])
+
+                system(<<-CMD)
+                  bundle exec rake airbrake:deploy \
+                    USERNAME=#{username} \
+                    ENVIRONMENT=#{fetch(:rails_env, 'production')} \
+                    REVISION=#{current_revision.strip} \
+                    REPOSITORY=#{repository} \
+                    VERSION=#{fetch(:app_version, nil)}
+                CMD
+              end
+
+              logger.info 'Notified Airbrake of the deploy'
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+
+  Airbrake::Capistrano.load_into(Capistrano::Configuration.instance)
+end

data/lib/airbrake/delayed_job/plugin.rb

@@ -0,0 +1,48 @@
+module Delayed
+  module Plugins
+    ##
+    # Provides integration with Delayed Job.
+    # rubocop:disable Lint/RescueException
+    class Airbrake < ::Delayed::Plugin
+      callbacks do |lifecycle|
+        lifecycle.around(:invoke_job) do |job, *args, &block|
+          begin
+            # Forward the call to the next callback in the callback chain
+            block.call(job, *args)
+          rescue Exception => exception
+            params = job.as_json.merge(
+              component: 'delayed_job',
+              action: job.payload_object.class.name
+            )
+
+            # If DelayedJob is used through ActiveJob, it contains extra info.
+            if job.payload_object.respond_to?(:job_data)
+              params[:active_job] = job.payload_object.job_data
+            end
+
+            ::Airbrake.notify(exception, params)
+            raise exception
+          end
+        end
+      end
+    end
+    # rubocop:enable Lint/RescueException
+  end
+end
+
+if RUBY_ENGINE == 'jruby' && defined?(Delayed::Backend::ActiveRecord::Job)
+  ##
+  # Workaround against JRuby bug:
+  # https://github.com/jruby/jruby/issues/3338
+  # rubocop:disable Style/ClassAndModuleChildren
+  class Delayed::Backend::ActiveRecord::Job
+    alias_method :old_to_ary, :to_ary
+
+    def to_ary
+      old_to_ary || [self]
+    end
+  end
+  # rubocop:enable Style/ClassAndModuleChildren
+end
+
+Delayed::Worker.plugins << Delayed::Plugins::Airbrake

data/lib/airbrake/rack/middleware.rb

@@ -0,0 +1,45 @@
+module Airbrake
+  module Rack
+    ##
+    # Airbrake Rack middleware for Rails and Sinatra applications (or any other
+    # Rack-compliant app). Any errors raised by the upstream application will be
+    # delivered to Airbrake and re-raised.
+    #
+    # The middleware automatically sends information about the framework that
+    # uses it (name and version).
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      ##
+      # Rescues any exceptions, sends them to Airbrake and re-raises the
+      # exception.
+      # @param [Hash] env the Rack environment
+      def call(env)
+        # rubocop:disable Lint/RescueException
+        begin
+          response = @app.call(env)
+        rescue Exception => ex
+          notify_airbrake(ex, env)
+          raise ex
+        end
+        # rubocop:enable Lint/RescueException
+
+        # The internal framework middlewares store exceptions inside the Rack
+        # env. See: https://goo.gl/Kd694n
+        exception = env['action_dispatch.exception'] || env['sinatra.error']
+        notify_airbrake(exception, env) if exception
+
+        response
+      end
+
+      private
+
+      def notify_airbrake(exception, env)
+        notice = NoticeBuilder.new(env).build_notice(exception)
+        Airbrake.notify(notice)
+      end
+    end
+  end
+end

data/lib/airbrake/rack/notice_builder.rb

@@ -0,0 +1,80 @@
+module Airbrake
+  module Rack
+    ##
+    # A helper class for filling notices with all sorts of useful information
+    # coming from the Rack environment.
+    class NoticeBuilder
+      ##
+      # @return [String] the name of the host machine
+      HOSTNAME = Socket.gethostname.freeze
+
+      ##
+      # @param [Hash{String=>Object}] rack_env The Rack environment
+      def initialize(rack_env)
+        @rack_env = rack_env
+        @request = ::Rack::Request.new(rack_env)
+        @controller = rack_env['action_controller.instance']
+        @session = @request.session
+        @user = Airbrake::Rack::User.extract(rack_env)
+
+        @framework_version =
+          if defined?(::Rails)
+            "Rails/#{::Rails.version}"
+          elsif defined?(::Sinatra)
+            "Sinatra/#{Sinatra::VERSION}"
+          else
+            "Rack.version/#{::Rack.version} Rack.release/#{::Rack.release}"
+          end.freeze
+      end
+
+      ##
+      # Adds context, session, params and other fields based on the Rack env.
+      #
+      # @param [Exception] exception
+      # @return [Airbrake::Notice] the notice with extra information
+      def build_notice(exception)
+        notice = Airbrake.build_notice(exception)
+
+        add_context(notice)
+        add_session(notice)
+        add_params(notice)
+
+        notice
+      end
+
+      private
+
+      def add_context(notice)
+        context = notice[:context]
+
+        context[:url] = @request.url
+        context[:userAgent] = @request.user_agent
+        context[:hostname] = HOSTNAME
+
+        if context.key?(:version)
+          context[:version] += " #{@framework_version}"
+        else
+          context[:version] = @framework_version
+        end
+
+        if @controller
+          context[:component] = @controller.controller_name
+          context[:action] = @controller.action_name
+        end
+
+        notice[:context].merge!(@user.to_hash) if @user
+
+        nil
+      end
+
+      def add_session(notice)
+        notice[:session] = @session if @session
+      end
+
+      def add_params(notice)
+        params = @request.env['action_dispatch.request.parameters']
+        notice[:params] = params if params
+      end
+    end
+  end
+end