airbrake 9.5.0

data/lib/airbrake/rack/middleware.rb

@@ -0,0 +1,100 @@
+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).
+    #
+    # For Rails apps the middleware collects route performance statistics.
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      # Thread-safe {call!}.
+      #
+      # @param [Hash] env the Rack environment
+      # @see https://github.com/airbrake/airbrake/issues/904
+      def call(env)
+        dup.call!(env)
+      end
+
+      # Rescues any exceptions, sends them to Airbrake and re-raises the
+      # exception. We also duplicate middleware to guarantee thread-safety.
+      #
+      # @param [Hash] env the Rack environment
+      def call!(env)
+        before_call(env)
+
+        begin
+          response = @app.call(env)
+        rescue Exception => ex # rubocop:disable Lint/RescueException
+          notify_airbrake(ex)
+          raise ex
+        end
+
+        exception = framework_exception(env)
+        notify_airbrake(exception) if exception
+
+        response
+      ensure
+        # Clear routes for the next request.
+        RequestStore.clear
+      end
+
+      private
+
+      def before_call(env)
+        # Rails hooks such as ActionControllerRouteSubscriber rely on this.
+        RequestStore[:routes] = {}
+        RequestStore[:request] = find_request(env)
+      end
+
+      def find_request(env)
+        if defined?(ActionDispatch::Request)
+          ActionDispatch::Request.new(env)
+        elsif defined?(Sinatra::Request)
+          Sinatra::Request.new(env)
+        else
+          ::Rack::Request.new(env)
+        end
+      end
+
+      def notify_airbrake(exception)
+        notice = Airbrake.build_notice(exception)
+        return unless notice
+
+        # ActionDispatch::Request correctly captures server port when using SSL:
+        # See: https://github.com/airbrake/airbrake/issues/802
+        notice.stash[:rack_request] = RequestStore[:request]
+
+        Airbrake.notify(notice)
+      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
+
+[
+  Airbrake::Rack::ContextFilter,
+  Airbrake::Rack::UserFilter,
+  Airbrake::Rack::SessionFilter,
+  Airbrake::Rack::HttpParamsFilter,
+  Airbrake::Rack::HttpHeadersFilter,
+  Airbrake::Rack::RouteFilter
+].each do |filter|
+  Airbrake.add_filter(filter.new)
+end

data/lib/airbrake/rack/request_body_filter.rb

@@ -0,0 +1,31 @@
+module Airbrake
+  module Rack
+    # A filter that appends Rack request body to the notice.
+    #
+    # @example
+    #   # Read and append up to 512 bytes from Rack request's body.
+    #   Airbrake.add_filter(Airbrake::Rack::RequestBodyFilter.new(512))
+    #
+    # @since v5.7.0
+    # @note This filter is *not* used by default.
+    class RequestBodyFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      # @param [Integer] length The maximum number of bytes to read
+      def initialize(length = 4096)
+        @length = length
+        @weight = 95
+      end
+
+      # @see Airbrake::FilterChain#refine
+      def call(notice)
+        return unless (request = notice.stash[:rack_request])
+        return unless request.body
+
+        notice[:environment][:body] = request.body.read(@length)
+        request.body.rewind
+      end
+    end
+  end
+end

data/lib/airbrake/rack/request_store.rb

@@ -0,0 +1,32 @@
+module Airbrake
+  module Rack
+    # RequestStore is a thin (and limited) wrapper around *Thread.current* that
+    # allows writing and reading thread-local variables under the +:airbrake+
+    # key.
+    # @api private
+    # @since v8.1.3
+    module RequestStore
+      class << self
+        # @return [Hash] a hash for all request-related data
+        def store
+          Thread.current[:airbrake] ||= {}
+        end
+
+        # @return [void]
+        def []=(key, value)
+          store[key] = value
+        end
+
+        # @return [Object]
+        def [](key)
+          store[key]
+        end
+
+        # @return [void]
+        def clear
+          Thread.current[:airbrake] = {}
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/rack/route_filter.rb

@@ -0,0 +1,53 @@
+module Airbrake
+  module Rack
+    # Adds route slugs to context/route.
+    # @since v7.5.0
+    class RouteFilter
+      attr_reader :weight
+
+      def initialize
+        @weight = 100
+      end
+
+      def call(notice)
+        return unless (request = notice.stash[:rack_request])
+
+        notice[:context][:route] =
+          if action_dispatch_request?(request)
+            rails_route(request)
+          elsif sinatra_request?(request)
+            sinatra_route(request)
+          end
+      end
+
+      private
+
+      def rails_route(request)
+        ::Rails.application.routes.router.recognize(request) do |route, _parameters|
+          # Rails can recognize multiple routes for the given request. For
+          # example, if we visit /users/2/edit, then Rails sees these routes:
+          #   * "/users/:id/edit(.:format)"
+          #   *  "/"
+          #
+          # We return the first route as, what it seems, the most optimal
+          # approach.
+          return route.path.spec.to_s
+        end
+      end
+
+      def sinatra_route(request)
+        return unless (route = request.env['sinatra.route'])
+        route.split(' ').drop(1).join(' ')
+      end
+
+      def action_dispatch_request?(request)
+        defined?(ActionDispatch::Request) &&
+          request.instance_of?(ActionDispatch::Request)
+      end
+
+      def sinatra_request?(request)
+        defined?(Sinatra::Request) && request.instance_of?(Sinatra::Request)
+      end
+    end
+  end
+end

data/lib/airbrake/rack/session_filter.rb

@@ -0,0 +1,23 @@
+module Airbrake
+  module Rack
+    # Adds HTTP session.
+    #
+    # @since v5.7.0
+    class SessionFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 96
+      end
+
+      # @see Airbrake::FilterChain#refine
+      def call(notice)
+        return unless (request = notice.stash[:rack_request])
+
+        session = request.session
+        notice[:session] = session if session
+      end
+    end
+  end
+end

data/lib/airbrake/rack/user.rb

@@ -0,0 +1,70 @@
+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'])
+          user = warden.user(run_callbacks: false)
+          # Early return to prevent unwanted possible authentication via
+          # calling the `current_user` method later.
+          # See: https://github.com/airbrake/airbrake/issues/641
+          return user ? new(user) : nil
+        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, true)
+        return unless [-1, 0].include?(controller.method(:current_user).arity)
+        begin
+          controller.__send__(:current_user)
+        rescue Exception => _e # rubocop:disable Lint/RescueException
+          nil
+        end
+      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)
+        return unless @user.respond_to?(key)
+        # try methods with no arguments or with variable number of arguments,
+        # where none of them are required
+        return unless @user.method(key).arity.between?(-1, 0)
+        String(@user.__send__(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/rack/user_filter.rb

@@ -0,0 +1,23 @@
+module Airbrake
+  module Rack
+    # Adds current user information.
+    #
+    # @since v8.0.1
+    class UserFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 99
+      end
+
+      # @see Airbrake::FilterChain#refine
+      def call(notice)
+        return unless (request = notice.stash[:rack_request])
+
+        user = Airbrake::Rack::User.extract(request.env)
+        notice[:context].merge!(user.as_json) if user
+      end
+    end
+  end
+end

data/lib/airbrake/rails.rb

@@ -0,0 +1,32 @@
+require 'airbrake/rails/railtie'
+
+module Airbrake
+  # Rails namespace holds all Rails-related functionality.
+  module Rails
+    def self.logger
+      if ENV['RAILS_LOG_TO_STDOUT'].present?
+        Logger.new(STDOUT, level: ::Rails.logger.level)
+      else
+        Logger.new(
+          ::Rails.root.join('log', 'airbrake.log'),
+
+          # Rails.logger is not set in some Rake tasks such as
+          # 'airbrake:deploy'. In this case we use a sensible fallback.
+          level: (::Rails.logger ? ::Rails.logger.level : Logger::ERROR)
+        )
+      end
+    end
+  end
+end
+
+if defined?(ActionController::Metal)
+  require 'airbrake/rails/action_controller'
+  module ActionController
+    # Adds support for Rails API/Metal for Rails < 5. Rails 5+ uses standard
+    # hooks.
+    # @see https://github.com/airbrake/airbrake/issues/821
+    class Metal
+      include Airbrake::Rails::ActionController
+    end
+  end
+end

data/lib/airbrake/rails/action_cable.rb

@@ -0,0 +1,33 @@
+require 'airbrake/rails/action_cable/notify_callback'
+
+%i[subscribe unsubscribe].each do |callback_name|
+  ActionCable::Channel::Base.set_callback(
+    callback_name, :around, prepend: true
+  ) do |channel, inner|
+    Airbrake::Rails::ActionCable::NotifyCallback.call(channel, inner)
+  end
+end
+
+module ActionCable
+  module Channel
+    # @since v8.3.0
+    # @api private
+    # @see https://github.com/rails/rails/blob/master/actioncable/lib/action_cable/channel/base.rb
+    class Base
+      alias perform_action_without_airbrake perform_action
+
+      def perform_action(*args, &block)
+        perform_action_without_airbrake(*args, &block)
+      rescue Exception => ex # rubocop:disable Lint/RescueException
+        Airbrake.notify(ex) do |notice|
+          notice.stash[:action_cable_connection] = connection
+          notice[:context][:component] = self.class
+          notice[:context][:action] = args.first['action']
+          notice[:params].merge!(args.first)
+        end
+
+        raise ex
+      end
+    end
+  end
+end

data/lib/airbrake/rails/action_cable/notify_callback.rb

@@ -0,0 +1,20 @@
+module Airbrake
+  module Rails
+    module ActionCable
+      # @since v8.3.0
+      # @api private
+      class NotifyCallback
+        def self.call(channel, block)
+          block.call
+        rescue Exception => ex # rubocop:disable Lint/RescueException
+          notice = Airbrake.build_notice(ex)
+          notice[:context][:component] = 'action_cable'
+          notice[:context][:action] = channel.channel_name
+          Airbrake.notify(notice)
+
+          raise ex
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/rails/action_controller.rb

@@ -0,0 +1,35 @@
+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, params = {}, &block)
+        return unless (notice = build_notice(exception, params))
+        Airbrake.notify(notice, params, &block)
+      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, params = {}, &block)
+        return unless (notice = build_notice(exception, params))
+        Airbrake.notify_sync(notice, params, &block)
+      end
+
+      # @param [Exception] exception
+      # @return [Airbrake::Notice] the notice with information from the Rack env
+      def build_notice(exception, params = {})
+        return unless (notice = Airbrake.build_notice(exception, params))
+        notice.stash[:rack_request] = request
+        notice
+      end
+    end
+  end
+end