dfg-airbrake 5.6.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 060fe33fe27f61ec2e753fc7b3fc753b4f8fd4a7
+  data.tar.gz: 14a5b8ba79abbd1d6b19ffb053e2e04828e2a834
+SHA512:
+  metadata.gz: d6a5aebe268567624f63f359e99b391158fc306b733c94f9e414f8755bfe164dba5fa8448671a386ba3f7799a07106d38324d53a66b96e5a0a3e482924dfa2d6
+  data.tar.gz: af44f375f3653d02d0f5a203ff8feec03dc05823bbc6e4c1c2486a023d5144677a4c927e5f1af372dc41e15bb681269d5e7ab8672feaeea492b57dfb6f99a7ea

data/lib/airbrake.rb

@@ -0,0 +1,57 @@
+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/user'
+  require 'airbrake/rack/notice_builder'
+  require 'airbrake/rack/middleware'
+
+  require 'airbrake/rails/railtie' if defined?(Rails)
+end
+
+require 'airbrake/rake/task_ext' if defined?(Rake::Task)
+require 'airbrake/resque/failure' if defined?(Resque)
+require 'airbrake/sidekiq/error_handler' if defined?(Sidekiq)
+# 2016-12-19
+# https://meta.discourse.org/t/54462
+# «The Plugin::Instance.find_all method incorrectly treats every file with the «plugin.rb» name
+# as a Discourse plugin».
+require 'airbrake/delayed_job/plugin1' if defined?(Delayed)
+
+##
+# This module reopens the original Airbrake module from airbrake-ruby and adds
+# integration specific methods.
+module Airbrake
+  class << self
+    ##
+    # Attaches a callback (builder) that runs every time the Rack integration
+    # reports an error. Can be used to attach additional data from the Rack
+    # request.
+    #
+    # @example Adding remote IP from the Rack environment
+    #   Airbrake.add_rack_builder do |notice, request|
+    #     notice[:params][:remoteIp] = request.env['REMOTE_IP']
+    #   end
+    #
+    # @yieldparam notice [Airbrake::Notice] notice that will be sent to Airbrake
+    # @yieldparam request [Rack::Request] current rack request
+    # @yieldreturn [void]
+    # @return [void]
+    # @since 5.1.0
+    def add_rack_builder(&block)
+      Airbrake::Rack::NoticeBuilder.add_builder(&block)
+    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
+end

data/lib/airbrake/capistrano/tasks.rb

@@ -0,0 +1,65 @@
+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
+      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
+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
+              username = Shellwords.shellescape(ENV['USER'] || ENV['USERNAME'])
+              command = <<-CMD
+                cd #{config.release_path} && \
+
+                RACK_ENV=#{fetch(:rack_env, nil)} \
+                RAILS_ENV=#{fetch(:rails_env, nil)} \
+
+                bundle exec rake airbrake:deploy \
+                  USERNAME=#{username} \
+                  ENVIRONMENT=#{fetch(:rails_env, 'production')} \
+                  REVISION=#{current_revision.strip} \
+                  REPOSITORY=#{repository} \
+                  VERSION=#{fetch(:app_version, nil)}
+              CMD
+
+              run(command, once: true)
+              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/plugin1.rb

@@ -0,0 +1,52 @@
+# 2016-12-19
+# https://meta.discourse.org/t/54462
+# «The Plugin::Instance.find_all method incorrectly treats every file with the «plugin.rb» name
+# as a Discourse plugin».
+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 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,59 @@
+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, notifier_name = :default)
+        @app = app
+        @notifier_name = notifier_name
+      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
+
+        exception = framework_exception(env)
+        notify_airbrake(exception, env) if exception
+
+        response
+      end
+
+      private
+
+      def notify_airbrake(exception, env)
+        notice = NoticeBuilder.new(env, @notifier_name).build_notice(exception)
+        return unless notice
+
+        Airbrake.notify(notice, {}, @notifier_name)
+      end
+
+      ##
+      # Web framework middlewares often store rescued exceptions inside the
+      # Rack env, but Rack doesn't have a standard key for it:
+      #
+      # - Rails uses action_dispatch.exception: https://goo.gl/Kd694n
+      # - Sinatra uses sinatra.error: https://goo.gl/LLkVL9
+      # - Goliath uses rack.exception: https://goo.gl/i7e1nA
+      def framework_exception(env)
+        env['action_dispatch.exception'] ||
+          env['sinatra.error'] ||
+          env['rack.exception']
+      end
+    end
+  end
+end

data/lib/airbrake/rack/notice_builder.rb

@@ -0,0 +1,125 @@
+module Airbrake
+  module Rack
+    ##
+    # A helper class for filling notices with all sorts of useful information
+    # coming from the Rack environment.
+    class NoticeBuilder
+      @builders = []
+
+      class << self
+        ##
+        # @return [Array<Proc>] the list of notice builders
+        attr_reader :builders
+
+        ##
+        # Adds user defined builders to the chain.
+        def add_builder(&block)
+          @builders << block
+        end
+      end
+
+      ##
+      # @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
+
+      ##
+      # @param [Hash{String=>Object}] rack_env The Rack environment
+      def initialize(rack_env, notifier_name = :default)
+        @rack_env = rack_env
+        @notifier_name = notifier_name
+        @request = ::Rack::Request.new(rack_env)
+      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)
+        return unless (notice = Airbrake.build_notice(exception, {}, @notifier_name))
+
+        NoticeBuilder.builders.each { |builder| builder.call(notice, @request) }
+        notice
+      end
+
+      ##
+      # Adds context (URL, User-Agent, framework version, controller and more).
+      add_builder do |notice, request|
+        context = notice[:context]
+
+        context[:url] = request.url
+        context[:userAgent] = request.user_agent
+
+        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
+
+        if context.key?(:version)
+          context[:version] += " #{framework_version}"
+        else
+          context[:version] = framework_version
+        end
+
+        controller = request.env['action_controller.instance']
+        if controller
+          context[:component] = controller.controller_name
+          context[:action] = controller.action_name
+        end
+
+        user = Airbrake::Rack::User.extract(request.env)
+        notice[:context].merge!(user.as_json) if user
+      end
+
+      ##
+      # Adds session.
+      add_builder do |notice, request|
+        session = request.session
+        notice[:session] = session if session
+      end
+
+      ##
+      # Adds HTTP request parameters.
+      add_builder do |notice, request|
+        notice[:params] = request.params
+
+        rails_params = request.env['action_dispatch.request.parameters']
+        notice[:params].merge!(rails_params) if rails_params
+      end
+
+      ##
+      # Adds HTTP referer, method and headers to the environment.
+      add_builder do |notice, 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[:environment].merge!(
+          httpMethod: request.request_method,
+          referer: request.referer,
+          headers: http_headers
+        )
+
+        if request.body
+          notice[:environment][:body] = request.body.read(4096)
+          request.body.rewind
+        end
+
+        notice[:environment]
+      end
+    end
+  end
+end

data/lib/airbrake/rack/user.rb

@@ -0,0 +1,61 @@
+module Airbrake
+  module Rack
+    ##
+    # Represents an authenticated user, which can be converted to Airbrake's
+    # payload format. Supports Warden and Omniauth authentication frameworks.
+    class User
+      # Finds the user in the Rack environment and creates a new user wrapper.
+      #
+      # @param [Hash{String=>Object}] rack_env The Rack environment
+      # @return [Airbrake::Rack::User, nil]
+      def self.extract(rack_env)
+        # Warden support (including Devise).
+        if (warden = rack_env['warden'])
+          if (user = warden.user(run_callbacks: false))
+            return new(user) if user
+          end
+        end
+
+        # Fallback mode (OmniAuth support included). Works only for Rails.
+        user = try_current_user(rack_env)
+        new(user) if user
+      end
+
+      def self.try_current_user(rack_env)
+        controller = rack_env['action_controller.instance']
+        return unless controller.respond_to?(:current_user)
+        return unless [-1, 0].include?(controller.method(:current_user).arity)
+        controller.current_user
+      end
+      private_class_method :try_current_user
+
+      def initialize(user)
+        @user = user
+      end
+
+      def as_json
+        user = {}
+
+        user[:id] = try_to_get(:id)
+        user[:name] = full_name
+        user[:username] = try_to_get(:username)
+        user[:email] = try_to_get(:email)
+
+        user = user.delete_if { |_key, val| val.nil? }
+        user.empty? ? user : { user: user }
+      end
+
+      private
+
+      def try_to_get(key)
+        String(@user.__send__(key)) if @user.respond_to?(key)
+      end
+
+      def full_name
+        # Try to get first and last names. If that fails, try to get just 'name'.
+        name = [try_to_get(:first_name), try_to_get(:last_name)].compact.join(' ')
+        name.empty? ? try_to_get(:name) : name
+      end
+    end
+  end
+end

data/lib/airbrake/rails/action_controller.rb

@@ -0,0 +1,37 @@
+module Airbrake
+  module Rails
+    ##
+    # Contains helper methods that can be used inside Rails controllers to send
+    # notices to Airbrake. The main benefit of using them instead of the direct
+    # API is that they automatically add information from the Rack environment
+    # to notices.
+    module ActionController
+      private
+
+      ##
+      # A helper method for sending notices to Airbrake *asynchronously*.
+      # Attaches information from the Rack env.
+      # @see Airbrake#notify, #notify_airbrake_sync
+      def notify_airbrake(exception, parameters = {}, notifier = :default)
+        return unless (notice = build_notice(exception))
+        Airbrake.notify(notice, parameters, notifier)
+      end
+
+      ##
+      # A helper method for sending notices to Airbrake *synchronously*.
+      # Attaches information from the Rack env.
+      # @see Airbrake#notify_sync, #notify_airbrake
+      def notify_airbrake_sync(exception, parameters = {}, notifier = :default)
+        return unless (notice = build_notice(exception))
+        Airbrake.notify_sync(notice, parameters, notifier)
+      end
+
+      ##
+      # @param [Exception] exception
+      # @return [Airbrake::Notice] the notice with information from the Rack env
+      def build_notice(exception)
+        Airbrake::Rack::NoticeBuilder.new(request.env).build_notice(exception)
+      end
+    end
+  end
+end