rails_mini_profiler 0

data/lib/rails_mini_profiler/middleware.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  class Middleware
+    def initialize(app)
+      @app = app
+      @config = RailsMiniProfiler.configuration
+      Tracing::Subscriptions.setup! { |trace| track_trace(trace) }
+    end
+
+    def call(env)
+      request = RequestWrapper.new(env: 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)
+      complete!(request_context)
+      request_context.saved? ? render_response(request_context) : result
+    end
+
+    def traces
+      Thread.current[:rails_mini_profiler_traces]
+    end
+
+    def traces=(traces)
+      Thread.current[:rails_mini_profiler_traces] = traces
+    end
+
+    def track_trace(event)
+      return if traces.nil?
+
+      trace = RailsMiniProfiler::Tracing::TraceFactory.create(event)
+      traces.append(trace) unless trace.is_a?(RailsMiniProfiler::Tracing::NullTrace)
+    end
+
+    private
+
+    def complete!(request_context)
+      request_context.complete_profiling!
+      request_context.save_results!
+      true
+    rescue ActiveRecord::ActiveRecordError => e
+      RailsMiniProfiler.logger.error("Could not save profile: #{e}")
+      false
+    end
+
+    def render_response(request_context)
+      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]
+    end
+
+    def profile(request_context)
+      ActiveSupport::Notifications.instrument('rails_mini_profiler.total_time') do
+        request = request_context.request
+        FlamegraphGuard.new(request_context).record { @app.call(request.env) }
+      end
+    end
+
+    def with_tracing(request_context)
+      self.traces = []
+      result = yield
+      request_context.traces = traces
+      self.traces = nil
+      result
+    end
+  end
+end

data/lib/rails_mini_profiler/models/base_model.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  # Thin wrappers around request/response classes
+  #
+  # @api private
+  module Models
+    # A pseudo model to be used to wrap profiling information. We can't use regular models, as their connecting
+    # to the database results in problems when profiling.
+    class BaseModel
+      include ActiveModel::Model
+
+      def initialize(*_args, **attributes)
+        super(attributes)
+      end
+
+      def to_h
+        instance_variables
+          .each_with_object({}) { |var, hash| hash[var.to_s.delete('@')] = instance_variable_get(var) }
+      end
+    end
+  end
+end

data/lib/rails_mini_profiler/redirect.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  # Renders a redirect response if the user should be redirected from the original request
+  class Redirect
+    include Engine.routes.url_helpers
+
+    # @param request_context [RequestContext] the current request context
+    def initialize(request_context)
+      @request = request_context.request
+      @profiled_request = request_context.profiled_request
+    end
+
+    # Renders a redirect to a specific resource under certain conditions
+    #
+    # When the user requests a Flamegraph using a parameter for a specific request, they are being served a redirect.
+    #
+    # @return [Boolean] false if no redirect happens
+    # @return [Array] response with status 302 and the new location to redirect to
+    def render
+      params = CGI.parse(@request.query_string).transform_values(&:first).with_indifferent_access
+      return redirect_to(flamegraph_path(@profiled_request.id)) if params[:rmp_flamegraph].present?
+
+      false
+    end
+
+    private
+
+    def redirect_to(location)
+      [302, { 'Location' => location, 'Content-Type' => 'text/html' }, ['Moved Temporarily']]
+    end
+  end
+end

data/lib/rails_mini_profiler/request_context.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  # A working context for the duration of a request, as it runs through Rails Mini Profiler's middleware
+  #
+  # Contains all information that is being gathered while profiling is active. At the end of the request processing,
+  # the request context is converted into a models which are then stored in the host apps database.
+  #
+  # @!attribute [r] request
+  #   @return [RequestWrapper] the request as sent to the application
+  # @!attribute response
+  #   @return [ResponseWrapper] the response as rendered by the application
+  # @!attribute profiled_request
+  #   @return [ProfiledRequest] the profiling data as gathered during profiling
+  # @!attribute traces
+  #   @return [Array<Models::Trace>] trace wrappers gathered during profiling
+  # @!attribute flamegraph
+  #   @return [Flamegraph] a Flamegraph, if recorded
+  class RequestContext
+    attr_reader :request
+
+    attr_accessor :response, :profiled_request, :traces, :flamegraph
+
+    # @param request [RequestWrapper] the request as sent to the application
+    def initialize(request)
+      @request = request
+      @env = request.env
+      @saved = false
+      @complete = false
+    end
+
+    # If a user is currently authorized
+    #
+    # @return [Boolean] true if the user is authorized
+    def authorized?
+      @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.flamegraph = RailsMiniProfiler::Flamegraph.new(data: flamegraph) if flamegraph.present?
+        profiled_request.save
+        insert_traces unless traces.empty?
+      end
+      @saved = true
+    end
+
+    def complete?
+      @complete
+    end
+
+    def saved?
+      @saved
+    end
+
+    private
+
+    def insert_traces
+      return if traces.empty?
+
+      timestamp = Time.zone.now
+      inserts = traces.map do |trace|
+        {
+          rmp_profiled_request_id: profiled_request.id,
+          created_at: timestamp,
+          updated_at: timestamp,
+          **trace.to_h.symbolize_keys # Symbolize keys needed for Ruby 2.6
+        }
+      end
+      RailsMiniProfiler::Trace.insert_all(inserts)
+    end
+  end
+end

data/lib/rails_mini_profiler/request_wrapper.rb

@@ -0,0 +1,69 @@
+# 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
+  #
+  # @api private
+  class RequestWrapper
+    attr_reader :body,
+                :method,
+                :path,
+                :query_string,
+                :env
+
+    def initialize(*_args, **attributes)
+      @attributes = attributes
+      setup
+    end
+
+    # The request headers
+    #
+    # @return [Hash] the 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
+    end
+  end
+end

data/lib/rails_mini_profiler/response_wrapper.rb

@@ -0,0 +1,32 @@
+# 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
+
+    def body
+      return '' unless json? || xml?
+
+      response&.body || ''
+    end
+
+    def media_type
+      @media_type ||= @rack_response.media_type
+    end
+
+    def json?
+      media_type =~ %r{application/json}
+    end
+
+    def xml?
+      media_type =~ %r{application/xml}
+    end
+  end
+end

data/lib/rails_mini_profiler/tracing/controller_tracer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  module Tracing
+    class ControllerTracer < Tracer
+      def trace
+        @event[:payload] = @event[:payload]
+                             .slice(:view_runtime, :db_runtime)
+                             .reject { |_k, v| v.blank? }
+                             .transform_values { |value| value&.round(2) }
+        super
+      end
+    end
+  end
+end

data/lib/rails_mini_profiler/tracing/null_trace.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  module Tracing
+    class NullTrace < Trace; end
+  end
+end

data/lib/rails_mini_profiler/tracing/sequel_tracer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  module Tracing
+    class SequelTracer < Tracer
+      def trace
+        return NullTrace.new if ignore?
+
+        payload = @event[:payload].slice(:name, :sql, :binds, :type_casted_binds)
+        typecasted_binds = payload[:type_casted_binds]
+        # Sometimes, typecasted binds are a proc. Not sure why. In those instances, we extract the typecasted
+        # values from the proc by executing call.
+        typecasted_binds = typecasted_binds.call if typecasted_binds.respond_to?(:call)
+        payload[:binds] = transform_binds(payload[:binds], typecasted_binds)
+        payload.delete(:type_casted_binds)
+        payload.reject { |_k, v| v.blank? }
+        @event[:payload] = payload
+        super
+      end
+
+      private
+
+      def transform_binds(binds, type_casted_binds)
+        binds.each_with_object([]).with_index do |(binding, object), i|
+          name = binding.name
+          value = type_casted_binds[i]
+          object << { name: name, value: value }
+        end
+      end
+
+      def ignore?
+        payload = @event[:payload]
+        !SqlTracker.new(name: payload[:name], query: payload[:sql]).track?
+      end
+    end
+  end
+end

data/lib/rails_mini_profiler/tracing/sequel_tracker.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  module Tracing
+    class SqlTracker
+      TRACKED_SQL_COMMANDS = %w[SELECT INSERT UPDATE DELETE].freeze
+      UNTRACKED_NAMES = %w[SCHEMA].freeze
+      UNTRACKED_TABLES = %w[
+        SCHEMA_MIGRATIONS
+        SQLITE_MASTER
+        ACTIVE_MONITORING_METRICS
+        SQLITE_TEMP_MASTER
+        SQLITE_VERSION
+        AR_INTERNAL_METADATA
+      ].freeze
+
+      def initialize(query:, name:)
+        @query = query.to_s.upcase
+        @name = name.to_s.upcase
+      end
+
+      def track?
+        query.start_with?(*TRACKED_SQL_COMMANDS) &&
+          !name.start_with?(*UNTRACKED_NAMES) &&
+          !untracked_tables?
+      end
+
+      private
+
+      attr_reader :query, :name
+
+      def untracked_tables?
+        UNTRACKED_TABLES.any? { |table| query.include?(table) }
+      end
+    end
+  end
+end

data/lib/rails_mini_profiler/tracing/subscriptions.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  module Tracing
+    class Subscriptions
+      DEFAULT_SUBSCRIPTIONS = %w[
+        sql.active_record
+        instantiation.active_record
+        render_template.action_view
+        render_partial.action_view
+        process_action.action_controller
+        rails_mini_profiler.total_time
+      ].freeze
+
+      class << self
+        def setup!(&callback)
+          DEFAULT_SUBSCRIPTIONS.each do |event|
+            subscribe(event, &callback)
+          end
+        end
+
+        private
+
+        def subscribe(*subscriptions, &callback)
+          subscriptions.each do |subscription|
+            ActiveSupport::Notifications.subscribe(subscription) do |event|
+              callback.call(event)
+            end
+          end
+        end
+      end
+    end
+  end
+end