rails_mini_profiler 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb1212a4d90c46143193b2173e9e136aa6757a74a6591137cba33169235d175d
-  data.tar.gz: f799849a5d978c2c22d39b3fa1f4be6c02541f75b7a2312d98a510a1d69a195b
+  metadata.gz: '08b93a903a5bb3b16310b3a918a1a52555a9ce5fc2a60624d0f2bb8158e3ddb5'
+  data.tar.gz: 88af5220a54c4f91e4506cd0423a853512dcc67235c65a22990d1c4fc1d92c25
 SHA512:
-  metadata.gz: ae143e874778e4af9560e5b6521003c5d4933ec86ffe5900a56c57b93791a3d0faa3ac18294cecccac12048dc35c38a70aa7a53ffa91b12d2025a89c0acc0384
-  data.tar.gz: f2a8ca075571593f1cce9d1b59910ea5aac8f95a06c277298be9e0e93be5dcd1b013fbaefbef22bf173f6e2db40fed29068cfda44d422aa372cdde30818ec9cf
+  metadata.gz: 2a41fec13f04188e895769fcb17004fdd6436aaddd8942ff4657beaffb7c0f4b63ca64d60f9877d119c1e363194ebd3c97e629216d0bf675fceb82cd49b6dcda
+  data.tar.gz: f5c81dbc3b627e48a0d9097fb587b37c2c299476adb87d01ace6c697e234b32f8fceee942045656f82f8c4d6ef6c082e58ad2f5619ccf2b4114b32764dae8c8f

data/README.md

@@ -153,7 +153,7 @@ Rails Mini Profiler allows you to configure various UI features.
 |---------------------|---------------------------|-------------------------------------------------------------------------------------------------|
 | `badge_enabled`     | `true`                    | Should the hedgehog 🦔 badge be injected into pages?                                             |
 | `badge_position`    | `'top-left'`              | Where to display the badge. Options are `'top-left', 'top-right', 'bottom-left, 'bottom-right'` |
-| `base_controller`   | `ApplicationController` | Which controller UI controllers should inherit from.                                            |
+| `base_controller`   | `ApplicationController`   | Which controller UI controllers should inherit from.                                            |
 | `page_size`         | `25`                      | The page size for lists shown in the UI.                                                        |
 | `webpacker_enabled` | `true`                    | Use Webpacker if available? Disable to fall back to the asset pipeline.                         |
 

data/app/controllers/rails_mini_profiler/application_controller.rb

@@ -6,15 +6,6 @@ module RailsMiniProfiler
 
     before_action :check_rmp_user
 
-    protected
-
-    def present(model, presenter_class = nil, **kwargs)
-      klass = presenter_class || "RailsMiniProfiler::#{model.class.to_s.demodulize}Presenter".constantize
-      presenter = klass.new(model, view_context, **kwargs)
-      yield(presenter) if block_given?
-      presenter
-    end
-
     private
 
     def handle(error, status = 500)

data/app/controllers/rails_mini_profiler/profiled_requests_controller.rb

@@ -67,6 +67,22 @@ module RailsMiniProfiler
       @configuration ||= RailsMiniProfiler.configuration
     end
 
+    def registry
+      @registry ||= RailsMiniProfiler::Tracers::Registry.new(configuration)
+    end
+
+    def present(model, presenter_class = nil, **kwargs)
+      klass = presenter_class || presenter_class(model)
+      klass.new(model, view_context, **kwargs)
+    end
+
+    def presenter_class(model)
+      return ProfiledRequestPresenter if model.is_a?(ProfiledRequest)
+
+      presenters = registry.presenters
+      presenters[model.name] || TracePresenter
+    end
+
     def payload_column
       if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
         # Cast json field to text to have access to the LIKE operator

data/app/models/rails_mini_profiler/profiled_request.rb

@@ -43,7 +43,7 @@ module RailsMiniProfiler
     def request=(request)
       self.request_body = request.body
       self.request_headers = request.headers
-      self.request_method = request.method
+      self.request_method = request.request_method
       self.request_path = request.path
       self.request_query_string = request.query_string
     end

data/app/models/rails_mini_profiler/trace.rb

@@ -23,24 +23,9 @@
 module RailsMiniProfiler
   class Trace < RailsMiniProfiler::ApplicationRecord
     self.table_name = RailsMiniProfiler.storage_configuration.traces_table
-    self.inheritance_column = :name
 
     belongs_to :profiled_request,
                class_name: 'RailsMiniProfiler::ProfiledRequest',
                foreign_key: :rmp_profiled_request_id
-
-    class << self
-      def find_sti_class(name)
-        subclasses = {
-          'process_action.action_controller' => RailsMiniProfiler::ControllerTrace,
-          'sql.active_record' => RailsMiniProfiler::SequelTrace,
-          'instantiation.active_record' => RailsMiniProfiler::InstantiationTrace,
-          'rails_mini_profiler.total_time' => RailsMiniProfiler::RmpTrace,
-          'render_template.action_view' => RailsMiniProfiler::RenderTemplateTrace,
-          'render_partial.action_view' => RailsMiniProfiler::RenderPartialTrace
-        }
-        subclasses[name] || self
-      end
-    end
   end
 end

data/app/presenters/rails_mini_profiler/controller_trace_presenter.rb

@@ -6,10 +6,18 @@ module RailsMiniProfiler
       'Action Controller'
     end
 
-    def payload
+    def view_runtime
+      payload['view_runtime']
+    end
+
+    def db_runtime
+      payload['db_runtime']
+    end
+
+    def content
       content_tag('div') do
         content_tag('pre', class: 'trace-payload') do
-          content_tag(:div, "View Time: #{model.view_runtime} ms, DB Time: #{model.db_runtime} ms",
+          content_tag(:div, "View Time: #{view_runtime} ms, DB Time: #{db_runtime} ms",
                       class: 'sequel-trace-query')
         end
       end

data/app/presenters/rails_mini_profiler/instantiation_trace_presenter.rb

@@ -3,12 +3,24 @@
 module RailsMiniProfiler
   class InstantiationTracePresenter < TracePresenter
     def label
-      "#{model.class_name} Instantiation"
+      "#{class_name} Instantiation"
+    end
+
+    def class_name
+      payload['class_name']
+    end
+
+    def record_count
+      payload['record_count']
+    end
+
+    def db_runtime
+      payload['db_runtime']
     end
 
     def description
-      record_string = 'Record'.pluralize(model.record_count)
-      "Instantiated #{model.record_count} #{model.class_name} #{record_string}"
+      record_string = 'Record'.pluralize(record_count)
+      "Instantiated #{record_count} #{class_name} #{record_string}"
     end
   end
 end

data/app/presenters/rails_mini_profiler/render_partial_trace_presenter.rb

@@ -2,10 +2,14 @@
 
 module RailsMiniProfiler
   class RenderPartialTracePresenter < TracePresenter
+    def identifier
+      payload['identifier']
+    end
+
     def label
       root = Rails.root.to_s.split('/').to_set
-      identifier = model.identifier.split('/').to_set
-      (root ^ identifier).drop(2).join('/').reverse.truncate(30).reverse
+      id = identifier.split('/').to_set
+      (root ^ id).drop(2).join('/').reverse.truncate(30).reverse
     end
   end
 end

data/app/presenters/rails_mini_profiler/render_template_trace_presenter.rb

@@ -2,10 +2,14 @@
 
 module RailsMiniProfiler
   class RenderTemplateTracePresenter < TracePresenter
+    def identifier
+      payload['identifier']
+    end
+
     def label
       root = Rails.root.to_s.split('/').to_set
-      identifier = model.identifier.split('/').to_set
-      (root ^ identifier).drop(2).join('/').reverse.truncate(30).reverse
+      id = identifier.split('/').to_set
+      (root ^ id).drop(2).join('/').reverse.truncate(30).reverse
     end
 
     def description

data/app/presenters/rails_mini_profiler/sequel_trace_presenter.rb

@@ -6,14 +6,26 @@ module RailsMiniProfiler
       sql_description
     end
 
+    def name
+      payload['name']
+    end
+
+    def sql
+      payload['sql']
+    end
+
+    def binds
+      payload['binds']
+    end
+
     alias description label
 
-    def payload
+    def content
       return nil if transaction?
 
       content_tag('div') do
         content_tag('pre', class: 'trace-payload') do
-          content_tag(:div, model.sql, class: 'sequel-trace-query')
+          content_tag(:div, sql, class: 'sequel-trace-query')
         end + binding_content
       end
     end
@@ -57,9 +69,9 @@ module RailsMiniProfiler
     end
 
     def simple_binds
-      return [] if model.binds.nil? || model.binds.empty?
+      return [] if binds.nil? || binds.empty?
 
-      model.binds.each_with_object({}) do |hash, object|
+      binds.each_with_object({}) do |hash, object|
         name = hash['name']
         value = hash['value']
         object[name] = value

data/app/presenters/rails_mini_profiler/trace_presenter.rb

@@ -18,7 +18,7 @@ module RailsMiniProfiler
       label
     end
 
-    def payload
+    def content
       nil
     end
 

data/app/views/rails_mini_profiler/profiled_requests/show/_trace.html.erb

@@ -7,7 +7,7 @@
         <button class="popover-close">x</button>
       </section>
       <section class="popover-body">
-        <%= trace.payload %>
+        <%= trace.content %>
 
         <% if trace.backtrace %>
           <section class="popover-footer">

data/lib/generators/rails_mini_profiler/templates/rails_mini_profiler.rb.erb

@@ -22,7 +22,7 @@ RailsMiniProfiler.configure do |config|
   # Configure the Rails Mini Profiler User Interface
   # config.ui.badge_enabled = true
   # config.ui.badge_position = 'top-left'
-  # config.ui.base_controller = 'ApplicationController'
+  # config.ui.base_controller = ApplicationController
   # config.ui.page_size = 25
   # config.ui.webpacker_enabled = true
 

data/lib/rails_mini_profiler/badge.rb

@@ -23,30 +23,39 @@ module RailsMiniProfiler
     #
     # @return [ResponseWrapper] The modified response
     def render
-      content_type = @original_response.headers['Content-Type']
-      return @original_response unless content_type =~ %r{text/html}
-
-      return @original_response unless @configuration.ui.badge_enabled
+      return @original_response unless render_badge?
 
-      modified_response = Rack::Response.new([], @original_response.status, @original_response.headers)
+      modified_response = ResponseWrapper.new([], @original_response.status, @original_response.headers)
       modified_response.write(modified_body)
       modified_response.finish
 
-      response = @original_response.response
-      response.close if response.respond_to?(:close)
+      @original_response.close if @original_response.respond_to?(:close)
 
-      ResponseWrapper.new(@original_response.status,
-                          @original_response.headers,
-                          modified_response)
+      modified_response
     end
 
     private
 
+    def render_badge?
+      content_type = @original_response.headers['Content-Type']
+      unless content_type =~ %r{text/html}
+        RailsMiniProfiler.logger.debug("badge not rendered, response has content type #{content_type}")
+        return false
+      end
+
+      unless @configuration.ui.badge_enabled
+        RailsMiniProfiler.logger.debug('badge not rendered, disabled in configuration')
+        return false
+      end
+
+      true
+    end
+
     # Modify the body of the original response
     #
     # @return String The modified body
     def modified_body
-      body = @original_response.response.body
+      body = @original_response.body
       index = body.rindex(%r{</body>}i) || body.rindex(%r{</html>}i)
       if index
         body.dup.insert(index, badge_content)

data/lib/rails_mini_profiler/configuration/user_interface.rb

@@ -35,10 +35,11 @@ module RailsMiniProfiler
 
     attr_accessor :badge_enabled,
                   :badge_position,
-                  :base_controller,
                   :page_size,
                   :webpacker_enabled
 
+    attr_writer :base_controller
+
     def initialize(**kwargs)
       defaults!
       kwargs.each { |key, value| instance_variable_set("@#{key}", value) }
@@ -48,11 +49,18 @@ module RailsMiniProfiler
     def defaults!
       @badge_enabled = true
       @badge_position = 'top-left'
-      @base_controller = default_base_controller
+      # We must not set base controller during when the app loads, aka during autoload time, as we are loading
+      # constants. Rather, we only load the base controller constants when any engine controllers are first initialized
+      # and call #base_controller
+      @base_controller = nil
       @page_size = 25
       @webpacker_enabled = true
     end
 
+    def base_controller
+      @base_controller ||= default_base_controller
+    end
+
     def default_base_controller
       app_controller_exists = class_exists?('::ApplicationController')
       return ::ApplicationController if app_controller_exists && ::ApplicationController < ActionController::Base

data/lib/rails_mini_profiler/configuration.rb

@@ -18,6 +18,8 @@ module RailsMiniProfiler
   #   @return [Array<String>] a list of regex patterns for paths to skip
   # @!attribute storage
   #   @return [Storage] the storage configuration
+  # @!attribute tracers
+  #   @return [Array<Symbol>] the list of enabled tracers
   # @!attribute ui
   #   @return [UserInterface] the ui configuration
   # @!attribute user_provider
@@ -30,6 +32,7 @@ module RailsMiniProfiler
                   :flamegraph_sample_rate,
                   :skip_paths,
                   :storage,
+                  :tracers,
                   :ui,
                   :user_provider
 
@@ -46,6 +49,7 @@ module RailsMiniProfiler
       @logger = RailsMiniProfiler::Logger.new(Rails.logger)
       @skip_paths = []
       @storage = Storage.new
+      @tracers = %i[controller instantiation sequel view rmp]
       @ui = UserInterface.new
       @user_provider = proc { |env| Rack::Request.new(env).ip }
     end

data/lib/rails_mini_profiler/middleware.rb

@@ -5,21 +5,23 @@ module RailsMiniProfiler
     def initialize(app)
       @app = app
       @config = RailsMiniProfiler.configuration
-      Tracing::Subscriptions.setup! { |trace| track_trace(trace) }
+      @registry = Tracers::Registry.setup!(@config)
+      Tracers::Subscriptions.setup!(@registry.tracers.keys) { |trace| track_trace(trace) }
+      @trace_factory = Tracers::TraceFactory.new(@registry)
     end
 
     def call(env)
-      request = RequestWrapper.new(env: env)
+      request = RequestWrapper.new(env)
       request_context = RequestContext.new(request)
       return @app.call(env) unless Guard.new(request_context).profile?
 
-      request_context.profiled_request = ProfiledRequest.new
       result = with_tracing(request_context) { profile(request_context) }
       return result unless request_context.authorized?
 
-      request_context.response = ResponseWrapper.new(*result)
+      status, headers, body = result
+      request_context.response = ResponseWrapper.new(body, status, headers)
       complete!(request_context)
-      request_context.saved? ? render_response(request_context) : result
+      request_context.saved? ? render_response(request_context).to_a : result
     ensure
       User.current_user = nil
     end
@@ -35,14 +37,13 @@ module RailsMiniProfiler
     def track_trace(event)
       return if traces.nil?
 
-      trace = RailsMiniProfiler::Tracing::TraceFactory.create(event)
-      traces.append(trace) unless trace.is_a?(RailsMiniProfiler::Tracing::NullTrace)
+      trace = @trace_factory.create(event)
+      traces.append(trace) unless trace.is_a?(RailsMiniProfiler::Tracers::NullTrace)
     end
 
     private
 
     def complete!(request_context)
-      request_context.complete_profiling!
       request_context.save_results!
       true
     rescue ActiveRecord::ActiveRecordError => e
@@ -54,8 +55,7 @@ module RailsMiniProfiler
       redirect = Redirect.new(request_context).render
       return redirect if redirect
 
-      modified_response = Badge.new(request_context).render
-      [modified_response.status, modified_response.headers, modified_response.response]
+      Badge.new(request_context).render
     end
 
     def profile(request_context)

data/lib/rails_mini_profiler/request_context.rb

@@ -10,7 +10,7 @@ module RailsMiniProfiler
   #   @return [RequestWrapper] the request as sent to the application
   # @!attribute response
   #   @return [ResponseWrapper] the response as rendered by the application
-  # @!attribute profiled_request
+  #   # @!attribute profiled_request
   #   @return [ProfiledRequest] the profiling data as gathered during profiling
   # @!attribute traces
   #   @return [Array<Models::Trace>] trace wrappers gathered during profiling
@@ -19,8 +19,10 @@ module RailsMiniProfiler
   class RequestContext
     attr_reader :request
 
-    attr_accessor :response, :profiled_request, :traces, :flamegraph
+    attr_accessor :response, :traces, :flamegraph, :profiled_request
 
+    # Create a new request context
+    #
     # @param request [RequestWrapper] the request as sent to the application
     def initialize(request)
       @request = request
@@ -36,39 +38,41 @@ module RailsMiniProfiler
       @authorized ||= User.get(@env).present?
     end
 
-    # Completes profiling, setting all data and preparing for saving it.
-    def complete_profiling!
-      profiled_request.user_id = User.current_user
-      profiled_request.request = @request
-      profiled_request.response = @response
-      total_time = traces.find { |trace| trace.name == 'rails_mini_profiler.total_time' }
-      profiled_request.total_time = total_time
-      @complete = true
-    end
-
     # Save profiling data in the database.
     #
     # This will store the profiled request, as well as any attached traces and Flamgraph.
     def save_results!
       ActiveRecord::Base.transaction do
+        profiled_request = build_profiled_request
         profiled_request.flamegraph = RailsMiniProfiler::Flamegraph.new(data: flamegraph) if flamegraph.present?
         profiled_request.save
-        insert_traces unless traces.empty?
+        insert_traces(profiled_request) unless traces.empty?
+        @profiled_request = profiled_request
       end
       @saved = true
     end
 
-    def complete?
-      @complete
-    end
-
+    # Check if profiling results have been saved
+    #
+    # @return [Boolean] true if profiling results have been saved
     def saved?
       @saved
     end
 
     private
 
-    def insert_traces
+    def build_profiled_request
+      new_profiled_request = ProfiledRequest.new
+      new_profiled_request.user_id = User.current_user
+      new_profiled_request.request = @request
+      new_profiled_request.response = @response
+      total_time = traces.find { |trace| trace.name == 'rails_mini_profiler.total_time' }
+      new_profiled_request.total_time = total_time
+      new_profiled_request
+    end
+
+    # We insert multiple at once for performance reasons.
+    def insert_traces(profiled_request)
       return if traces.empty?
 
       timestamp = Time.zone.now

data/lib/rails_mini_profiler/request_wrapper.rb

@@ -1,69 +1,26 @@
 # frozen_string_literal: true
 
 module RailsMiniProfiler
-  # A convenience wrapper around [Rack::Env]
-  #
-  # @!attribute body
-  #   @return [String] the request body
-  # @!attribute method
-  #   @return [String] the request method
-  # @!attribute path
-  #   @return [String] the request path
-  # @!attribute query_string
-  #   @return [String] the request query string
-  # @!attribute env
-  #   @return [Rack::Env] the original env
+  # A convenience wrapper extending {Rack::Request}
   #
   # @api private
-  class RequestWrapper
-    attr_reader :body,
-                :method,
-                :path,
-                :query_string,
-                :env
+  class RequestWrapper < Rack::Request
+    # Convenience method to read the request body as String
+    #
+    # @return [String] the request body
+    def body
+      return '' unless super
 
-    def initialize(*_args, **attributes)
-      @attributes = attributes
-      setup
+      body = super.read
+      super.rewind
+      body
     end
 
     # The request headers
     #
-    # @return [Hash] the headers
+    # @return [Hash] the request headers
     def headers
-      @attributes[:headers] || @env.select { |k, _v| k.start_with? 'HTTP_' } || {}
-    end
-
-    private
-
-    def setup
-      @env = @attributes[:env] || {}
-      @method = setup_method
-      @query_string = setup_query_string
-      @path = setup_path
-      @body = setup_body
-    end
-
-    def setup_method
-      @attributes[:method] || @env['REQUEST_METHOD'] || 'GET'
-    end
-
-    def setup_query_string
-      @attributes[:query_string] || @env['QUERY_STRING'] || ''
-    end
-
-    def setup_path
-      @attributes[:path] || @env['PATH_INFO'] || '/'
-    end
-
-    def setup_body
-      return @attributes[:body] if @attributes[:body]
-
-      return '' unless @env['rack.input']
-
-      body = @env['rack.input'].read
-      @env['rack.input'].rewind
-      body
+      env.select { |k, _v| k.start_with? 'HTTP_' } || {}
     end
   end
 end

data/lib/rails_mini_profiler/response_wrapper.rb

@@ -1,24 +1,28 @@
 # frozen_string_literal: true
 
 module RailsMiniProfiler
-  class ResponseWrapper
-    attr_reader :response, :rack_response
-
-    delegate :status, :headers, to: :rack_response
-
-    def initialize(status, headers, response)
-      @rack_response = Rack::Response.new(response, status, headers)
-      @response = response
-    end
-
+  # A convenience wrapper extending {Rack::Response}
+  #
+  # @api private
+  class ResponseWrapper < Rack::Response
+    # Return the response body as String
+    #
+    # Depending on preceding middleware, response bodies may be Strings, Arrays or literally anything else. This method
+    # converts whatever it is to a string so we can store it later.
+    #
+    # @return [String] of the response body
     def body
-      return '' unless json? || xml?
-
-      response&.body || ''
-    end
-
-    def media_type
-      @media_type ||= @rack_response.media_type
+      body = super
+      case body
+      when String
+        body
+      when Array
+        body.join
+      when ActionDispatch::Response::RackBody
+        body.body
+      else
+        ''
+      end
     end
 
     def json?

data/lib/rails_mini_profiler/{tracing → tracers}/controller_tracer.rb

@@ -1,8 +1,22 @@
 # frozen_string_literal: true
 
 module RailsMiniProfiler
-  module Tracing
+  module Tracers
     class ControllerTracer < Tracer
+      class << self
+        def subscribes_to
+          'process_action.action_controller'
+        end
+
+        def build_from(event)
+          new(event).trace
+        end
+
+        def presents
+          ControllerTracePresenter
+        end
+      end
+
       def trace
         @event[:payload] = @event[:payload]
                              .slice(:view_runtime, :db_runtime)