airbrake 9.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 29bdd7916d90d84ac4933c2ce14d9069bd719a371bf822a3b886175841b2005c
+  data.tar.gz: 94f382b83ce554984a9c4e8162241be85baa78739d928e3c74081cfb17217f1a
+SHA512:
+  metadata.gz: e7e27d67804da299808bd87f6d2f201ab778ef344ff377283536d5be2082c579df9e54102eb83d48a5cadc78cf434bfcb7bf3c999a816b449f8930e539c96743
+  data.tar.gz: '028d1865c3e42686c54455164087d401f3dabbd1380b915aec7ca8191e0f777dc26c32930c9118bd160ef1bd6ba63f1fac289a4786f9fc720c98f7a3eadfe2ae'

data/lib/airbrake.rb

@@ -0,0 +1,30 @@
+require 'shellwords'
+require 'English'
+
+# Core library that sends notices.
+# See: https://github.com/airbrake/airbrake-ruby
+require 'airbrake-ruby'
+
+require 'airbrake/version'
+
+# Automatically load needed files for the environment the library is running in.
+if defined?(Rack)
+  require 'airbrake/rack'
+
+  require 'airbrake/rails' if defined?(Rails)
+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)
+
+require 'airbrake/logger'
+
+# 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

@@ -0,0 +1,6 @@
+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,38 @@
+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,21 @@
+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,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
+
+            # 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
+
+            ::Airbrake.notify(exception, params) do |notice|
+              notice[:context][:component] = 'delayed_job'
+              notice[:context][:action] = job_class || job.payload_object.class.name
+            end
+
+            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 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,101 @@
+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

data/lib/airbrake/rack.rb

@@ -0,0 +1,35 @@
+require 'airbrake/rack/user'
+require 'airbrake/rack/user_filter'
+require 'airbrake/rack/context_filter'
+require 'airbrake/rack/session_filter'
+require 'airbrake/rack/http_params_filter'
+require 'airbrake/rack/http_headers_filter'
+require 'airbrake/rack/request_body_filter'
+require 'airbrake/rack/route_filter'
+require 'airbrake/rack/middleware'
+require 'airbrake/rack/request_store'
+require 'airbrake/rack/instrumentable'
+
+module Airbrake
+  # Rack is a namespace for all Rack-related code.
+  module Rack
+    # @since v9.2.0
+    # @api public
+    def self.capture_timing(label)
+      routes = Airbrake::Rack::RequestStore[:routes]
+      if !routes || routes.none?
+        result = yield
+      else
+        timed_trace = Airbrake::TimedTrace.span(label) do
+          result = yield
+        end
+
+        routes.each do |_route_path, params|
+          params[:groups].merge!(timed_trace.spans)
+        end
+      end
+
+      result
+    end
+  end
+end

data/lib/airbrake/rack/context_filter.rb

@@ -0,0 +1,58 @@
+module Airbrake
+  module Rack
+    # Adds context (URL, User-Agent, framework version, controller and more).
+    #
+    # @since v5.7.0
+    class ContextFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 99
+      end
+
+      # @see Airbrake::FilterChain#refine
+      def call(notice)
+        return unless (request = notice.stash[:rack_request])
+
+        context = notice[:context]
+
+        context[:url] = request.url
+        context[:userAddr] = request.ip
+        context[:userAgent] = request.user_agent
+
+        add_framework_version(context)
+
+        controller = request.env['action_controller.instance']
+        return unless controller
+
+        context[:component] = controller.controller_name
+        context[:action] = controller.action_name
+      end
+
+      private
+
+      def add_framework_version(context)
+        if context.key?(:versions)
+          context[:versions].merge!(framework_version)
+        else
+          context[:versions] = framework_version
+        end
+      end
+
+      def framework_version
+        @framework_version ||=
+          if defined?(::Rails) && ::Rails.respond_to?(:version)
+            { 'rails' => ::Rails.version }
+          elsif defined?(::Sinatra)
+            { 'sinatra' => Sinatra::VERSION }
+          else
+            {
+              'rack_version' => ::Rack.version,
+              'rack_release' => ::Rack.release
+            }
+          end
+      end
+    end
+  end
+end

data/lib/airbrake/rack/http_headers_filter.rb

@@ -0,0 +1,42 @@
+module Airbrake
+  module Rack
+    # Adds HTTP request parameters.
+    #
+    # @since v5.7.0
+    class HttpHeadersFilter
+      # @return [Array<String>] the prefixes of the majority of HTTP headers in
+      #   Rack (some prefixes match the header names for simplicity)
+      HTTP_HEADER_PREFIXES = [
+        'HTTP_'.freeze,
+        'CONTENT_TYPE'.freeze,
+        'CONTENT_LENGTH'.freeze
+      ].freeze
+
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 98
+      end
+
+      # @see Airbrake::FilterChain#refine
+      def call(notice)
+        return unless (request = notice.stash[:rack_request])
+
+        http_headers = request.env.map.with_object({}) do |(key, value), headers|
+          if HTTP_HEADER_PREFIXES.any? { |prefix| key.to_s.start_with?(prefix) }
+            headers[key] = value
+          end
+
+          headers
+        end
+
+        notice[:context].merge!(
+          httpMethod: request.request_method,
+          referer: request.referer,
+          headers: http_headers
+        )
+      end
+    end
+  end
+end

data/lib/airbrake/rack/http_params_filter.rb

@@ -0,0 +1,25 @@
+module Airbrake
+  module Rack
+    # Adds HTTP request parameters.
+    #
+    # @since v5.7.0
+    class HttpParamsFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 97
+      end
+
+      # @see Airbrake::FilterChain#refine
+      def call(notice)
+        return unless (request = notice.stash[:rack_request])
+
+        notice[:params].merge!(request.params)
+
+        rails_params = request.env['action_dispatch.request.parameters']
+        notice[:params].merge!(rails_params) if rails_params
+      end
+    end
+  end
+end

data/lib/airbrake/rack/instrumentable.rb

@@ -0,0 +1,28 @@
+module Airbrake
+  module Rack
+    # Instrumentable holds methods that simplify instrumenting Rack apps.
+    # @example
+    #   class UsersController
+    #     extend Airbrake::Rack::Instrumentable
+    #
+    #     def index
+    #       # ...
+    #     end
+    #     airbrake_capture_timing :index
+    #   end
+    #
+    # @api public
+    # @since v9.2.0
+    module Instrumentable
+      def airbrake_capture_timing(method_name, label: method_name.to_s)
+        alias_method "#{method_name}_without_airbrake", method_name
+
+        define_method(method_name) do |*args|
+          Airbrake::Rack.capture_timing(label) do
+            __send__("#{method_name}_without_airbrake", *args)
+          end
+        end
+      end
+    end
+  end
+end