airbrake 3.1.6 → 11.0.0

data/lib/airbrake/rack/request_body_filter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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,34 @@
+# frozen_string_literal: true
+
+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,51 @@
+# frozen_string_literal: true
+
+require 'airbrake/rails/app'
+
+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)
+        return unless (route = Airbrake::Rails::App.recognize_route(request))
+
+        route.path
+      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,25 @@
+# frozen_string_literal: true
+
+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,74 @@
+# frozen_string_literal: true
+
+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,25 @@
+# frozen_string_literal: true
+
+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

@@ -1,40 +1,34 @@
-require 'airbrake'
-require 'airbrake/rails/controller_methods'
-require 'airbrake/rails/action_controller_catcher'
-require 'airbrake/rails/error_lookup'
-require 'airbrake/rails/javascript_notifier'
+# frozen_string_literal: true
+
+require 'airbrake/rails/railtie'
 
 module Airbrake
+  # Rails namespace holds all Rails-related functionality.
   module Rails
-    def self.initialize
-      if defined?(ActionController::Base)
-        ActionController::Base.send(:include, Airbrake::Rails::ActionControllerCatcher)
-        ActionController::Base.send(:include, Airbrake::Rails::ErrorLookup)
-        ActionController::Base.send(:include, Airbrake::Rails::ControllerMethods)
-        ActionController::Base.send(:include, Airbrake::Rails::JavascriptNotifier)
-      end
-
-      rails_logger = if defined?(::Rails.logger)
-                       ::Rails.logger
-                     elsif defined?(RAILS_DEFAULT_LOGGER)
-                       RAILS_DEFAULT_LOGGER
-                     end
-
-      if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:middleware)
-        ::Rails.configuration.middleware.insert_after 'ActionController::Failsafe',
-                                                      Airbrake::Rack
-        ::Rails.configuration.middleware.insert_after 'Rack::Lock',
-                                                      Airbrake::UserInformer
-      end
+    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'),
 
-      Airbrake.configure(true) do |config|
-        config.logger           = rails_logger
-        config.environment_name = defined?(::Rails.env) && ::Rails.env || defined?(RAILS_ENV) && RAILS_ENV
-        config.project_root     = defined?(::Rails.root) && ::Rails.root || defined?(RAILS_ROOT) && RAILS_ROOT
-        config.framework        = defined?(::Rails.version) && "Rails: #{::Rails.version}" || defined?(::Rails::VERSION::STRING) && "Rails: #{::Rails::VERSION::STRING}"
+          # 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
 
-Airbrake::Rails.initialize
+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,35 @@
+# frozen_string_literal: true
+
+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,22 @@
+# frozen_string_literal: true
+
+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,40 @@
+# frozen_string_literal: true
+
+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

data/lib/airbrake/rails/action_controller_notify_subscriber.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'airbrake/rails/event'
+
+module Airbrake
+  module Rails
+    # ActionControllerNotifySubscriber sends route stat information, including
+    # performance data.
+    #
+    # @since v8.0.0
+    class ActionControllerNotifySubscriber
+      def call(*args)
+        return unless Airbrake::Config.instance.performance_stats
+
+        routes = Airbrake::Rack::RequestStore[:routes]
+        return if !routes || routes.none?
+
+        event = Airbrake::Rails::Event.new(*args)
+
+        routes.each do |route, _params|
+          Airbrake.notify_request(
+            method: event.method,
+            route: route,
+            status_code: event.status_code,
+            timing: event.duration,
+            time: event.time,
+          )
+        end
+      end
+    end
+  end
+end