airbrake 3.1.6 → 11.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 81da57e8a5a47cfafd0a69d4d4c89e100301ba4c5e48418866ce584a95fe3632
+  data.tar.gz: c24d6f44c8eae4ad946471098620b16c6973d9272b0363f2420305b35374b7a2
+SHA512:
+  metadata.gz: 95b80ba3b1bf3771695c22fc28511a44347a4c8b841fc51d80f5abe14eb204147502f22599c2663a69f8b95986e1dd0cc7c026983957ecedb1761df4ab4311f5
+  data.tar.gz: 0dc035ee0b9b791eb13b2b7be401e46b5ab4fb5b906f5b180123b4bd9d4e3fd3a83439ffafe29e0371e39e71697575b0790992e5f240349b5113ad26a47b1dbf

data/lib/airbrake.rb

@@ -1,159 +1,32 @@
-require "girl_friday"
-require 'net/http'
-require 'net/https'
-require 'rubygems'
-require 'airbrake/extensions/blank'
-require 'airbrake/version'
-require 'airbrake/configuration'
-require 'airbrake/notice'
-require 'airbrake/sender'
-require 'airbrake/backtrace'
-require 'airbrake/rack'
-require 'airbrake/user_informer'
-
-require 'airbrake/railtie' if defined?(Rails::Railtie)
-
-module Airbrake
-  API_VERSION = "2.3"
-  LOG_PREFIX = "** [Airbrake] "
-
-  HEADERS = {
-    'Content-type'             => 'text/xml',
-    'Accept'                   => 'text/xml, application/xml'
-  }
-
-  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}")
-    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
+# frozen_string_literal: true
 
-    # 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
-    end
+require 'shellwords'
+require 'English'
 
-    # Writes out the given message to the #logger
-    def write_verbose_log(message)
-      logger.debug LOG_PREFIX + message if logger
-    end
+# Core library that sends notices.
+# See: https://github.com/airbrake/airbrake-ruby
+require 'airbrake-ruby'
 
-    # Look for the Rails logger currently defined
-    def logger
-      self.configuration.logger
-    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 = Sender.new(configuration)
-      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.
-    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
+require 'airbrake/version'
 
-      result
-    end
+# Automatically load needed files for the environment the library is running in.
+if defined?(Rack)
+  require 'airbrake/rack'
 
-    private
+  require 'airbrake/rails' if defined?(Rails)
+end
 
-    def send_notice(notice)
-      if configuration.public?
-        if configuration.async?
-          configuration.async.call(notice)
-        else
-          sender.send_to_airbrake(notice)
-        end
-      end
-    end
+require 'airbrake/rake' if defined?(Rake::Task)
+require 'airbrake/resque' if defined?(Resque)
+require 'airbrake/sidekiq' if defined?(Sidekiq)
+require 'airbrake/shoryuken' if defined?(Shoryuken)
+require 'airbrake/delayed_job' if defined?(Delayed)
+require 'airbrake/sneakers' if defined?(Sneakers)
 
-    def 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
+require 'airbrake/logger'
 
-    def 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
+# Notify of unhandled exceptions, if there were any, but ignore SystemExit.
+at_exit do
+  Airbrake.notify_sync($ERROR_INFO) if $ERROR_INFO
+  Airbrake.close
 end

data/lib/airbrake/capistrano.rb

@@ -1,44 +1,8 @@
-# Defines deploy:notify_airbrake which will send information about the deploy to Airbrake.
-require 'capistrano'
+# frozen_string_literal: true
 
-module Airbrake
-  module Capistrano
-    def self.load_into(configuration)
-      configuration.load do
-        after "deploy",            "airbrake:deploy"
-        after "deploy:migrations", "airbrake:deploy"
-        after "deploy:cold",       "airbrake:deploy"
-
-        namespace :airbrake do
-          desc <<-DESC
-            Notify Airbrake of the deployment by running the notification on the REMOTE machine.
-              - Run remotely so we use remote API keys, environment, etc.
-          DESC
-          task :deploy, :except => { :no_release => true } do
-            rails_env = fetch(:rails_env, "production")
-            airbrake_env = fetch(:airbrake_env, fetch(:rails_env, "production"))
-            local_user = ENV['USER'] || ENV['USERNAME']
-            executable = RUBY_PLATFORM.downcase.include?('mswin') ? fetch(:rake, 'rake.bat') : fetch(:rake, 'rake')
-            directory = configuration.current_release
-            notify_command = "cd #{directory}; #{executable} RAILS_ENV=#{rails_env} airbrake:deploy TO=#{airbrake_env} REVISION=#{current_revision} REPO=#{repository} USER=#{local_user}"
-            notify_command << " DRY_RUN=true" if dry_run
-            notify_command << " API_KEY=#{ENV['API_KEY']}" if ENV['API_KEY']
-            logger.info "Notifying Airbrake of Deploy (#{notify_command})"
-            if configuration.dry_run
-              logger.info "DRY RUN: Notification not actually run."
-            else
-              result = ""
-              run(notify_command, :once => true) { |ch, stream, data| result << data }
-              # TODO: Check if SSL is active on account via result content.
-            end
-            logger.info "Airbrake Notification Complete."
-          end
-        end
-      end
-    end
-  end
-end
-
-if Capistrano::Configuration.instance
-  Airbrake::Capistrano.load_into(Capistrano::Configuration.instance)
+if defined?(Capistrano::VERSION) &&
+   Gem::Version.new(Capistrano::VERSION).release >= Gem::Version.new('3.0.0')
+  require 'airbrake/capistrano/capistrano3'
+else
+  require 'airbrake/capistrano/capistrano2'
 end

data/lib/airbrake/capistrano/capistrano2.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+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
+            run(
+              <<-CMD, once: true
+                cd #{config.release_path} && \
+
+                RACK_ENV=#{fetch(:rack_env, nil)} \
+                RAILS_ENV=#{fetch(:rails_env, nil)} \
+
+                bundle exec rake airbrake:deploy \
+                  USERNAME=#{Shellwords.shellescape(ENV['USER'] || ENV['USERNAME'])} \
+                  ENVIRONMENT=#{fetch(:airbrake_env, fetch(:rails_env, 'production'))} \
+                  REVISION=#{current_revision.strip} \
+                  REPOSITORY=#{repository} \
+                  VERSION=#{fetch(:app_version, nil)}
+              CMD
+            )
+            logger.info 'Notified Airbrake of the deploy'
+          end
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+end
+
+Airbrake::Capistrano.load_into(Capistrano::Configuration.instance)

data/lib/airbrake/capistrano/capistrano3.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+namespace :airbrake do
+  desc "Notify Airbrake of the deploy"
+  task :deploy do
+    role = roles(:all, select: :primary).first || roles(:all).first
+    on role do
+      within release_path do
+        with rails_env: fetch(:rails_env, fetch(:stage)) do
+          execute :bundle, :exec, :rake, <<-CMD
+            airbrake:deploy USERNAME=#{Shellwords.shellescape(local_user)} \
+                            ENVIRONMENT=#{fetch(:airbrake_env, 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

data/lib/airbrake/delayed_job.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Delayed
+  module Plugins
+    # Provides integration with Delayed Job.
+    # rubocop:disable Metrics/BlockLength
+    class Airbrake < ::Delayed::Plugin
+      callbacks do |lifecycle|
+        lifecycle.around(:invoke_job) do |job, *args, &block|
+          begin
+            timing = ::Airbrake::Benchmark.measure do
+              # Forward the call to the next callback in the callback chain
+              block.call(job, *args)
+            end
+          rescue Exception => exception # rubocop:disable Lint/RescueException
+            params = job.as_json
+
+            # 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
+              job_class = job.payload_object.job_data['job_class']
+            end
+
+            action = job_class || job.payload_object.class.name
+
+            ::Airbrake.notify(exception, params) do |notice|
+              notice[:context][:component] = 'delayed_job'
+              notice[:context][:action] = action
+            end
+
+            ::Airbrake.notify_queue(
+              queue: action,
+              error_count: 1,
+              timing: 0.01,
+            )
+
+            raise exception
+          else
+            ::Airbrake.notify_queue(
+              queue: job_class || job.payload_object.class.name,
+              error_count: 0,
+              timing: timing,
+            )
+          end
+        end
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  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 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/logger.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'delegate'
+
+module Airbrake
+  # Decorator for +Logger+ from stdlib. Endows loggers the ability to both log
+  # and report errors to Airbrake.
+  #
+  # @example
+  #   # Create a logger like you normally do and decorate it.
+  #   logger = Airbrake::AirbrakeLogger.new(Logger.new(STDOUT))
+  #
+  #   # Just use the logger like you normally do.
+  #   logger.fatal('oops')
+  class AirbrakeLogger < SimpleDelegator
+    # @example
+    #   # Assign a custom Airbrake notifier
+    #   logger.airbrake_notifier = Airbrake::NoticeNotifier.new
+    # @return [Airbrake::Notifier] notifier to be used to send notices
+    attr_accessor :airbrake_notifier
+
+    # @return [Integer]
+    attr_reader :airbrake_level
+
+    def initialize(logger)
+      __setobj__(logger)
+      @airbrake_notifier = Airbrake
+      self.level = logger.level
+    end
+
+    # @see Logger#warn
+    def warn(progname = nil, &block)
+      notify_airbrake(Logger::WARN, progname)
+      super
+    end
+
+    # @see Logger#error
+    def error(progname = nil, &block)
+      notify_airbrake(Logger::ERROR, progname)
+      super
+    end
+
+    # @see Logger#fatal
+    def fatal(progname = nil, &block)
+      notify_airbrake(Logger::FATAL, progname)
+      super
+    end
+
+    # @see Logger#unknown
+    def unknown(progname = nil, &block)
+      notify_airbrake(Logger::UNKNOWN, progname)
+      super
+    end
+
+    # @see Logger#level=
+    def level=(value)
+      self.airbrake_level = value < Logger::WARN ? Logger::WARN : value
+      super
+    end
+
+    # Sets airbrake severity level. Does not permit values below `Logger::WARN`.
+    #
+    # @example
+    #   logger.airbrake_level = Logger::FATAL
+    # @return [void]
+    def airbrake_level=(level)
+      if level < Logger::WARN
+        raise "Airbrake severity level #{level} is not allowed. " \
+              "Minimum allowed level is #{Logger::WARN}"
+      end
+      @airbrake_level = level
+    end
+
+    private
+
+    def notify_airbrake(severity, progname)
+      return if severity < @airbrake_level || !@airbrake_notifier
+
+      @airbrake_notifier.notify(progname) do |notice|
+        # Get rid of unwanted internal Logger frames. Examples:
+        # * /ruby-2.4.0/lib/ruby/2.4.0/logger.rb
+        # * /gems/activesupport-4.2.7.1/lib/active_support/logger.rb
+        backtrace = notice[:errors].first[:backtrace]
+        notice[:errors].first[:backtrace] =
+          backtrace.drop_while { |frame| frame[:file] =~ %r{/logger.rb\z} }
+
+        notice[:context][:component] = 'log'
+        notice[:context][:severity] = normalize_severity(severity)
+      end
+    end
+
+    def normalize_severity(severity)
+      (case severity
+       when Logger::WARN then 'warning'
+       when Logger::ERROR, Logger::UNKNOWN then 'error'
+       when Logger::FATAL then 'critical'
+       else
+         raise "Unknown airbrake severity: #{severity}"
+       end).freeze
+    end
+  end
+end