celerbrake 0.1.0

data/lib/celerbrake/rack/request_store.rb

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

data/lib/celerbrake/rack/route_filter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'celerbrake/rails/app'
+
+module Celerbrake
+  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 = Celerbrake::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/celerbrake/rack/session_filter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rack
+    # Adds HTTP session.
+    #
+    # @since v5.7.0
+    class SessionFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 96
+      end
+
+      # @see Celerbrake::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/celerbrake/rack/user.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rack
+    # Represents an authenticated user, which can be converted to Celerbrake'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 [Celerbrake::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/celerbrake/celerbrake/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/celerbrake/rack/user_filter.rb

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

data/lib/celerbrake/rack.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'celerbrake/rack/user'
+require 'celerbrake/rack/user_filter'
+require 'celerbrake/rack/context_filter'
+require 'celerbrake/rack/session_filter'
+require 'celerbrake/rack/http_params_filter'
+require 'celerbrake/rack/http_headers_filter'
+require 'celerbrake/rack/request_body_filter'
+require 'celerbrake/rack/route_filter'
+require 'celerbrake/rack/middleware'
+require 'celerbrake/rack/request_store'
+require 'celerbrake/rack/instrumentable'
+
+module Celerbrake
+  # Rack is a namespace for all Rack-related code.
+  module Rack
+    # @since v9.2.0
+    # @api public
+    def self.capture_timing(label)
+      return yield unless Celerbrake::Config.instance.performance_stats
+
+      routes = Celerbrake::Rack::RequestStore[:routes]
+      if !routes || routes.none?
+        result = yield
+      else
+        timed_trace = Celerbrake::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/celerbrake/rails/action_cable/notify_callback.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  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 = Celerbrake.build_notice(ex)
+          notice[:context][:component] = 'action_cable'
+          notice[:context][:action] = channel.channel_name
+          Celerbrake.notify(notice)
+
+          raise ex
+        end
+      end
+    end
+  end
+end

data/lib/celerbrake/rails/action_cable.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'celerbrake/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|
+    Celerbrake::Rails::ActionCable::NotifyCallback.call(channel, inner)
+  end
+end
+
+module Celerbrake
+  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
+      module Base
+        def perform_action(*args, &block)
+          super(*args, &block)
+        rescue Exception => ex # rubocop:disable Lint/RescueException
+          Celerbrake.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
+end
+
+ActionCable::Channel::Base.prepend(Celerbrake::ActionCable::Channel::Base)

data/lib/celerbrake/rails/action_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rails
+    # Contains helper methods that can be used inside Rails controllers to send
+    # notices to Celerbrake. 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 Celerbrake *asynchronously*.
+      # Attaches information from the Rack env.
+      # @see Celerbrake#notify, #notify_celerbrake_sync
+      def notify_celerbrake(exception, params = {}, &block)
+        return unless (notice = build_notice(exception, params))
+
+        Celerbrake.notify(notice, params, &block)
+      end
+
+      # A helper method for sending notices to Celerbrake *synchronously*.
+      # Attaches information from the Rack env.
+      # @see Celerbrake#notify_sync, #notify_celerbrake
+      def notify_celerbrake_sync(exception, params = {}, &block)
+        return unless (notice = build_notice(exception, params))
+
+        Celerbrake.notify_sync(notice, params, &block)
+      end
+
+      # @param [Exception] exception
+      # @return [Celerbrake::Notice] the notice with information from the Rack env
+      def build_notice(exception, params = {})
+        return unless (notice = Celerbrake.build_notice(exception, params))
+
+        notice.stash[:rack_request] = request
+        notice
+      end
+    end
+  end
+end

data/lib/celerbrake/rails/action_controller_notify_subscriber.rb

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

data/lib/celerbrake/rails/action_controller_performance_breakdown_subscriber.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'celerbrake/rails/event'
+
+module Celerbrake
+  module Rails
+    # @since v8.3.0
+    class ActionControllerPerformanceBreakdownSubscriber
+      def call(*args)
+        return unless Celerbrake::Config.instance.performance_stats
+
+        routes = Celerbrake::Rack::RequestStore[:routes]
+        return if !routes || routes.none?
+
+        event = Celerbrake::Rails::Event.new(*args)
+        stash = build_stash
+
+        routes.each do |route, params|
+          groups = event.groups.merge(params[:groups])
+          next if groups.none?
+
+          breakdown_info = {
+            method: event.method,
+            route: route,
+            response_type: event.response_type,
+            groups: groups,
+            timing: event.duration,
+            time: event.time,
+          }
+
+          Celerbrake.notify_performance_breakdown(breakdown_info, stash)
+        end
+      end
+
+      private
+
+      def build_stash
+        stash = {}
+        request = Celerbrake::Rack::RequestStore[:request]
+        return stash unless request
+
+        stash[:request] = request
+        if (user = Celerbrake::Rack::User.extract(request.env))
+          stash.merge!(user.as_json)
+        end
+
+        stash
+      end
+    end
+  end
+end

data/lib/celerbrake/rails/action_controller_route_subscriber.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'celerbrake/rails/event'
+require 'celerbrake/rails/app'
+
+module Celerbrake
+  module Rails
+    # ActionControllerRouteSubscriber sends route stat information, including
+    # performance data.
+    #
+    # @since v8.0.0
+    class ActionControllerRouteSubscriber
+      def call(*args)
+        return unless Celerbrake::Config.instance.performance_stats
+
+        # We don't track routeless events.
+        return unless (routes = Celerbrake::Rack::RequestStore[:routes])
+
+        event = Celerbrake::Rails::Event.new(*args)
+        route = Celerbrake::Rails::App.recognize_route(
+          Celerbrake::Rack::RequestStore[:request],
+        )
+        return unless route
+
+        routes[route.path] = {
+          method: event.method,
+          response_type: event.response_type,
+          groups: {},
+        }
+      end
+    end
+  end
+end

data/lib/celerbrake/rails/active_job.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rails
+    # Enables support for exceptions occurring in ActiveJob jobs.
+    module ActiveJob
+      extend ActiveSupport::Concern
+
+      def self.notify_celerbrake(exception, job)
+        notice = Celerbrake.build_notice(exception)
+        notice[:context][:component] = 'active_job'
+        notice[:context][:action] = job.class.name
+        notice[:params].merge!(job.serialize)
+
+        Celerbrake.notify(notice)
+
+        raise exception
+      end
+
+      def self.perform(job, block)
+        timing = Celerbrake::Benchmark.measure do
+          block.call
+        end
+      rescue StandardError => exception
+        Celerbrake.notify_queue(
+          queue: job.class.name,
+          error_count: 1,
+          timing: 0.01,
+        )
+        raise exception
+      else
+        Celerbrake.notify_queue(
+          queue: job.class.name,
+          error_count: 0,
+          timing: timing,
+        )
+      end
+
+      included do
+        rescue_from(Exception) do |exception|
+          Celerbrake::Rails::ActiveJob.notify_celerbrake(exception, self)
+        end
+
+        around_perform do |job, block|
+          Celerbrake::Rails::ActiveJob.perform(job, block)
+        end
+      end
+    end
+  end
+end

data/lib/celerbrake/rails/active_record.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rails
+    # Rails <4.2 has a bug with regard to swallowing exceptions in the
+    # +after_commit+ and the +after_rollback+ hooks: it doesn't bubble up
+    # exceptions from there.
+    #
+    # This module makes it possible to report exceptions occurring there.
+    #
+    # @see https://github.com/rails/rails/pull/14488 Detailed description of the
+    #   bug and the fix
+    # @see https://goo.gl/348lor Rails 4.2+ implementation (fixed)
+    # @see https://goo.gl/ddFNg7 Rails <4.2 implementation (bugged)
+    module ActiveRecord
+      # Patches default +run_callbacks+ with our version, which is capable of
+      # notifying about exceptions.
+      #
+      # rubocop:disable Lint/RescueException
+      def run_callbacks(kind, *args, &block)
+        # Let the post process handle the exception if it's not a bugged hook.
+        return super unless %i[commit rollback].include?(kind)
+
+        # Handle the exception ourselves. The 'ex' exception won't be
+        # propagated, therefore we must notify it here.
+        begin
+          super
+        rescue Exception => ex
+          Celerbrake.notify(ex)
+          raise ex
+        end
+      end
+      # rubocop:enable Lint/RescueException
+    end
+  end
+end

data/lib/celerbrake/rails/active_record_subscriber.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'celerbrake/rails/event'
+require 'celerbrake/rails/backtrace_cleaner'
+
+module Celerbrake
+  module Rails
+    # ActiveRecordSubscriber sends SQL information, including performance data.
+    #
+    # @since v8.1.0
+    class ActiveRecordSubscriber
+      def call(*args)
+        return unless Celerbrake::Config.instance.query_stats
+
+        routes = Celerbrake::Rack::RequestStore[:routes]
+        return if !routes || routes.none?
+
+        event = Celerbrake::Rails::Event.new(*args)
+        frame = last_caller
+
+        routes.each do |route, params|
+          Celerbrake.notify_query(
+            route: route,
+            method: params[:method],
+            query: event.sql,
+            func: frame[:function],
+            file: frame[:file],
+            line: frame[:line],
+            timing: event.duration,
+            time: event.time,
+          )
+        end
+      end
+
+      private
+
+      def last_caller
+        exception = StandardError.new
+        exception.set_backtrace(
+          Celerbrake::Rails::BacktraceCleaner.clean(Kernel.caller),
+        )
+        Celerbrake::Backtrace.parse(exception).first || {}
+      end
+    end
+  end
+end

data/lib/celerbrake/rails/app.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rails
+    # App is a wrapper around Rails.application.
+    #
+    # @since v9.0.3
+    # @api private
+    class App
+      Route = Struct.new(:path)
+
+      # @param [] request
+      # @return [Celerbrake::Rails::App::Route, nil]
+      # rubocop:disable Metrics/AbcSize
+      def self.recognize_route(request)
+        # Duplicate `request` because `recognize` *can* strip the request's
+        # `path_info`, which results in broken engine links (when the engine has
+        # an isolated namespace).
+        request_copy = request.dup
+
+        # Save original script name because `router.recognize(request)` mutates
+        # it. It's a Rails bug. More info in:
+        #   * https://github.com/celerbrake/celerbrake/issues/1072
+        #   * https://github.com/rails/rails/issues/31152
+        original_script_name = request.env['SCRIPT_NAME']
+
+        # We must search every engine individually to find a concrete route. If
+        # we rely only on the `Rails.application.routes.router`, then the
+        # recognize call would return the root route, neglecting PATH_INFO
+        # completely. For example:
+        #   * a request is made to `marketing#pricing`
+        #   * `Rails.application` recognizes it as `marketing#/` (incorrect)
+        #   * `Marketing::Engine` recognizes it as `marketing#/pricing` (correct)
+        engines.each do |engine|
+          engine.routes.router.recognize(request_copy) do |route, _params|
+            # Restore original script name. Remove this code when/if the Rails
+            # bug is fixed: https://github.com/celerbrake/celerbrake/issues/1072
+            request.env['SCRIPT_NAME'] = original_script_name
+
+            # Skip "catch-all" routes such as:
+            #   get '*path => 'pages#about'
+            #
+            # Ideally, we should be using `route.glob?` but in Rails 7+ this
+            # call would fail with a `NoMethodError`. This is because in
+            # Rails 7+ the AST for the route is not kept in memory anymore.
+            #
+            # See: https://github.com/rails/rails/pull/43006#discussion_r783895766
+            next if route.path.spec.any?(ActionDispatch::Journey::Nodes::Star)
+
+            path =
+              if engine == ::Rails.application
+                route.path.spec.to_s
+              else
+                "#{engine.engine_name}##{route.path.spec}"
+              end
+
+            # 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.new(path)
+          end
+        end
+
+        nil
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def self.engines
+        @engines ||= [*::Rails::Engine.subclasses, ::Rails.application]
+      end
+      private_class_method :engines
+    end
+  end
+end