rails_mini_profiler 0

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

@@ -0,0 +1,13 @@
+import "@rails-mini-profiler/assets"
+
+// Import styles
+import "@rails-mini-profiler/assets/dist/rails-mini-profiler.css";
+
+// Import images
+//
+// You may simplify this when using a glob loader (e.g glob-import-loader)
+<%- Dir.chdir(RailsMiniProfiler::Engine.root.join('app/javascript/images')) do -%>
+  <%- Dir.glob('**/*').each do |file| -%>
+import "@rails-mini-profiler/assets/dist/images/<%= file %>";
+  <%- end -%>
+<%- end -%>

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

@@ -0,0 +1,29 @@
+# Rails Mini Profiler Initializer (<%= RailsMiniProfiler::VERSION %>)
+
+# Customize to your hearts content. If you remove this file, Rails Mini Profiler will use sensible defaults.
+# For more information see https://github.com/hschne/rails-mini-profiler#configuration
+RailsMiniProfiler.configure do |config|
+  # Customize when Rails Mini Profiler should run
+  config.enabled = proc { |env| Rails.env.development? || env['HTTP_RMP_ENABLED'].present? }
+
+  # Configure Flamegraph generation
+  config.flamegraph_enabled = true
+  # config.flamegraph_sample_rate = 0.5
+
+  # Configure endpoints to profile
+  config.skip_paths = []
+
+  # Configure how Rails Mini Profiler stores profiling information
+  # config.storage.database = :rmp_database
+  # config.storage.profiled_requests_table = :rmp_profiled_requests
+  # config.storage.traces_table = :rmp_traces
+  # config.storage.flamegraphs_table = :rmp_flamegraphs
+
+  # Configure the Rails Mini Profiler User Interface
+  # config.ui.badge_enabled = true
+  # config.ui.badge_position = 'top-left'
+  # config.ui.page_size = 25
+
+  # Customize how users are detected
+  config.user_provider = proc { |env| Rack::Request.new(env).ip }
+end

data/lib/rails_mini_profiler/badge.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative '../../app/helpers/rails_mini_profiler/application_helper'
+
+module RailsMiniProfiler
+  # Wraps functionality to render an interactive badge on top of HTML responses
+  #
+  # @api private
+  class Badge
+    include InlineSvg::ActionView::Helpers
+    include RailsMiniProfiler::ApplicationHelper
+    include Engine.routes.url_helpers
+
+    # @param request_context [RequestContext] The current request context
+    # @param configuration [Configuration] The current configuration
+    def initialize(request_context, configuration: RailsMiniProfiler.configuration)
+      @configuration = configuration
+      @profiled_request = request_context.profiled_request
+      @original_response = request_context.response
+    end
+
+    # Inject the badge into the response
+    #
+    # @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
+
+      modified_response = Rack::Response.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)
+
+      ResponseWrapper.new(@original_response.status,
+                          @original_response.headers,
+                          modified_response)
+    end
+
+    private
+
+    # Modify the body of the original response
+    #
+    # @return String The modified body
+    def modified_body
+      body = @original_response.response.body
+      index = body.rindex(%r{</body>}i) || body.rindex(%r{</html>}i)
+      if index
+        body.dup.insert(index, badge_content)
+      else
+        body
+      end
+    end
+
+    # Render the badge template
+    #
+    # @return String The badge HTML content to be injected
+    def badge_content
+      html = IO.read(File.expand_path('../../app/views/rails_mini_profiler/badge.html.erb', __dir__))
+      @position = css_position
+      template = ERB.new(html)
+      template.result(binding)
+    end
+
+    # Transform the configuration position into CSS style positions
+    #
+    # @return String The badge position as CSS style
+    def css_position
+      case @configuration.ui.badge_position
+      when 'top-right'
+        'top: 5px; right: 5px;'
+      when 'bottom-left'
+        'bottom: 5px; left: 5px;'
+      when 'bottom-right'
+        'bottom: 5px; right: 5px;'
+      else
+        'top: 5px; left: 5px;'
+      end
+    end
+  end
+end

data/lib/rails_mini_profiler/configuration/storage.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  # Configure how profiling data is stored within your Rails app.
+  #
+  # @!attribute database
+  #   @return [Symbol] which database to connect to
+  # @!attribute profiled_requests_table
+  #   @return [Symbol] where to store profiled requests
+  # @!attribute traces_table
+  #   @return [Symbol] where to store traces
+  # @!attribute flamegraphs_table
+  #   @return [Symbol] where to store flamegraphs
+  class Storage
+    class << self
+      # Construct a new configuration instance
+      #
+      # @return [Storage] a new storage configuration
+      def configuration
+        @configuration ||= new
+      end
+
+      # Configure how profiling data is stored
+      #
+      # @yieldreturn [Storage] a new storage configuration object
+      def configure
+        yield(configuration)
+        configuration
+      end
+    end
+
+    attr_accessor :database, :profiled_requests_table, :traces_table, :flamegraphs_table
+
+    def initialize(**kwargs)
+      defaults!
+      kwargs.each { |key, value| instance_variable_set("@#{key}", value) }
+    end
+
+    # Reset the configuration to default values
+    def defaults!
+      @database = nil
+      @profiled_requests_table = 'rmp_profiled_requests'
+      @flamegraphs_table = 'rmp_flamegraphs'
+      @traces_table = 'rmp_traces'
+    end
+  end
+end

data/lib/rails_mini_profiler/configuration/user_interface.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  # Configure various aspects about Rails Mini Profilers UI.
+  #
+  # @!attribute badge_enabled
+  #   @see Badge
+  #   @return [Boolean] if the badge should be enabled
+  # @!attribute badge_position
+  #   @see Badge
+  #   @return [String] the position of the interactive HTML badge
+  # @!attribute page_size
+  #   @return [Integer] how many items to render per page in list views
+  class UserInterface
+    class << self
+      # Construct a new UI configuration instance
+      #
+      # @return [UserInterface] a new storage configuration
+      def configuration
+        @configuration ||= new
+      end
+
+      # Configure how profiling data is shown to the user
+      #
+      # @yieldreturn [UserInterface] a new UI configuration object
+      def configure
+        yield(configuration)
+        configuration
+      end
+    end
+
+    attr_accessor :badge_enabled,
+                  :badge_position,
+                  :page_size
+
+    def initialize(**kwargs)
+      defaults!
+      kwargs.each { |key, value| instance_variable_set("@#{key}", value) }
+    end
+
+    # Reset the configuration to default values
+    def defaults!
+      @badge_enabled = true
+      @badge_position = 'top-left'
+      @page_size = 25
+    end
+  end
+end

data/lib/rails_mini_profiler/configuration.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'rails_mini_profiler/configuration/storage'
+require 'rails_mini_profiler/configuration/user_interface'
+
+module RailsMiniProfiler
+  # The main Rails Mini Profiler configuration object
+  #
+  # @!attribute [r] logger
+  #   @return [Logger] the current logger
+  # @!attribute enabled
+  #   @return [Boolean] if the profiler is enabled
+  # @!attribute flamegraph_enabled
+  #   @return [Boolean] if Flamegraph recording is enabled
+  # @!attribute flamegraph_sample_rate
+  #   @return [Float] the sample rate in samples per millisecond
+  # @!attribute skip_paths
+  #   @return [Array<String>] a list of regex patterns for paths to skip
+  # @!attribute storage
+  #   @return [Storage] the storage configuration
+  # @!attribute ui
+  #   @return [UserInterface] the ui configuration
+  # @!attribute user_provider
+  #   @return [Proc] a proc to identify a user based on a rack env
+  class Configuration
+    attr_reader :logger
+
+    attr_accessor :enabled,
+                  :flamegraph_enabled,
+                  :flamegraph_sample_rate,
+                  :skip_paths,
+                  :storage,
+                  :ui,
+                  :user_provider
+
+    def initialize(**kwargs)
+      reset
+      kwargs.each { |key, value| instance_variable_set("@#{key}", value) }
+    end
+
+    # Reset the configuration to default values
+    def reset
+      @enabled = proc { |_env| Rails.env.development? || Rails.env.test? }
+      @flamegraph_enabled = true
+      @flamegraph_sample_rate = 0.5
+      @logger = RailsMiniProfiler::Logger.new(Rails.logger)
+      @skip_paths = []
+      @storage = Storage.new
+      @ui = UserInterface.new
+      @user_provider = proc { |env| Rack::Request.new(env).ip }
+    end
+
+    # Set the logger
+    #
+    # @param logger [Logger]
+    #   The logger to be used. If set to nil, the Rails default logger is used and the log level set to fatal
+    def logger=(logger)
+      if logger.nil?
+        @logger.level = Logger::FATAL
+      else
+        @logger = logger
+      end
+    end
+  end
+end

data/lib/rails_mini_profiler/engine.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  # The Rails Mini Profiler engine
+  #
+  # Injects a a custom [Middleware] into an existing Rails app to record request profiling information.
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsMiniProfiler
+
+    initializer 'rails_mini_profiler.add_middleware' do |app|
+      app.middleware.use(RailsMiniProfiler::Middleware)
+    end
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    initializer 'rails_mini_profiler_add_static assets' do |app|
+      app.middleware.insert_before(ActionDispatch::Static, ActionDispatch::Static, "#{root}/public")
+    end
+
+    # If sprockets is not being used then there is no need to hook into asset compilation. Calling config.assets
+    # without Sprockets installed breaks compilation.
+    if defined?(Sprockets::Rails)
+      initializer 'rails_mini_profiler.assets.precompile', group: :all do |app|
+        app.config.assets.precompile += %w[
+          rails_mini_profiler.js
+          rails_mini_profiler/application.css
+          vendor/assets/images
+        ]
+      end
+    end
+  end
+end

data/lib/rails_mini_profiler/flamegraph_guard.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  class FlamegraphGuard
+    def initialize(request_context, configuration: RailsMiniProfiler.configuration)
+      @request_context = request_context
+      @request = request_context.request
+      @configuration = configuration
+    end
+
+    def record(&block)
+      return block.call unless enabled?
+
+      sample_rate = @configuration.flamegraph_sample_rate
+      if StackProf.running?
+        RailsMiniProfiler.logger.error('Stackprof is already running, cannot record Flamegraph')
+        return block.call
+      end
+
+      result = nil
+      flamegraph = StackProf.run(mode: :wall, raw: true, aggregate: false, interval: (sample_rate * 1000).to_i) do
+        result = block.call
+      end
+
+      unless flamegraph
+        RailsMiniProfiler.logger.error('Failed to record Flamegraph, possibly due to concurrent requests')
+        return result
+      end
+
+      @request_context.flamegraph = flamegraph.to_json
+      result
+    end
+
+    private
+
+    def enabled?
+      defined?(StackProf) && StackProf.respond_to?(:run) && config_enabled?
+    end
+
+    def config_enabled?
+      params = CGI.parse(@request.query_string).transform_values(&:first).with_indifferent_access
+      return params[:rmp_flamegraph] if params[:rmp_flamegraph]
+
+      RailsMiniProfiler.configuration.flamegraph_enabled
+    end
+  end
+end

data/lib/rails_mini_profiler/guard.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  # Encapsulates guard conditions on whether or not to run certain parts of the profiler.
+  class Guard
+    # @param request_context [RequestContext] the current request context
+    # @param configuration [Configuration] the current configuration
+    def initialize(request_context, configuration: RailsMiniProfiler.configuration)
+      @request_context = request_context
+      @request = request_context.request
+      @configuration = configuration
+    end
+
+    # Whether or not to profile
+    #
+    # Profiling is disabled the profiler has been flat out disabled in the configuration or if the current request path
+    # matches on of the ignored paths.
+    #
+    # @return [Boolean] false if no profiling should be done
+    def profile?
+      return false unless enabled?
+
+      return false if ignored_path?
+
+      true
+    end
+
+    private
+
+    # Is the path of the current request an ignored one?
+    #
+    # @return [Boolean] true if the path is ignored. Per default, paths going to the engine itself are ignored, as are
+    #   asset requests, and the paths the user has configured.
+    def ignored_path?
+      return true if /#{Engine.routes.find_script_name({})}/.match?(@request.path)
+
+      return true if /assets/.match?(@request.path)
+
+      ignored_paths = @configuration.skip_paths
+      return true if Regexp.union(ignored_paths).match?(@request.path)
+
+      false
+    end
+
+    # Is the profiler enabled?
+    #
+    # Takes into account the current request env to decide if the profiler is enabled.
+    #
+    # @return [Boolean] false if the profiler is disabled
+    def enabled?
+      enabled = @configuration.enabled
+      return enabled unless enabled.respond_to?(:call)
+
+      enabled.call(@request.env)
+    end
+  end
+end

data/lib/rails_mini_profiler/logger.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  # Construct a new custom logger to log from within the engine
+  module Logger
+    # Extends a logger with additional formatting
+    #
+    # @return [Logger] a customized logger
+    def self.new(logger)
+      logger = logger.dup
+
+      logger.formatter = logger.formatter ? logger.formatter.dup : ActiveSupport::Logger::SimpleFormatter.new
+
+      logger.formatter.extend Formatter
+      logger.extend(self)
+    end
+
+    # Custom formatter to add a RailsMiniProfiler tag to log messages
+    module Formatter
+      def call(severity, timestamp, progname, msg)
+        super(severity, timestamp, progname, "[RailsMiniProfiler] #{msg}")
+      end
+    end
+  end
+end