rails_mini_profiler 0.1.0

data/lib/rails_mini_profiler/guard.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  class Guard
+    def initialize(request_context, configuration: RailsMiniProfiler.configuration)
+      @request_context = request_context
+      @request = request_context.request
+      @configuration = configuration
+    end
+
+    def profile?
+      return false unless enabled?
+
+      return false if ignored_path?
+
+      true
+    end
+
+    def store?
+      return false unless @request_context.user
+
+      true
+    end
+
+    private
+
+    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
+
+    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,20 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  module 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
+
+    module Formatter
+      def call(severity, timestamp, progname, msg)
+        super(severity, timestamp, progname, "[RailsMiniProfiler] #{msg}")
+      end
+    end
+  end
+end

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
+      Tracers.setup! { |trace| track_trace(trace) }
+    end
+
+    def call(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)
+      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 = Tracers.build_trace(event)
+      traces.append(trace)
+    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,18 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  module Models
+    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/models/trace.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  module Models
+    class Trace < BaseModel
+      attr_accessor :id, :name, :start, :finish, :duration, :payload, :backtrace, :allocations, :created_at, :updated_at
+    end
+  end
+end

data/lib/rails_mini_profiler/redirect.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  class Redirect
+    include Engine.routes.url_helpers
+
+    def initialize(request_context)
+      @request = request_context.request
+      @profiled_request = request_context.profiled_request
+    end
+
+    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]
+
+      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,62 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  class RequestContext
+    attr_reader :request
+
+    attr_accessor :response, :profiled_request, :traces, :flamegraph
+
+    def initialize(request)
+      @request = request
+      @env = request.env
+      @saved = false
+      @complete = false
+    end
+
+    def user_id
+      @user_id ||= User.current_user
+    end
+
+    def authorized?
+      @authorized ||= User.get(@env).present?
+    end
+
+    def complete_profiling!
+      profiled_request.user_id = user_id
+      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
+
+    def save_results!
+      ActiveRecord::Base.transaction do
+        profiled_request.flamegraph = 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, **trace.to_h, created_at: timestamp, updated_at: timestamp }
+      end
+      RailsMiniProfiler::Trace.insert_all(inserts)
+    end
+  end
+end

data/lib/rails_mini_profiler/request_wrapper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  class RequestWrapper
+    attr_reader :body,
+                :method,
+                :path,
+                :query_string,
+                :env
+
+    def initialize(env = {})
+      @env = env
+      @method = @env['REQUEST_METHOD'] || 'GET'
+      @query_string = @env['QUERY_STRING'] || ''
+      @path = @env['PATH_INFO'] || '/'
+      @body = read_body
+    end
+
+    def headers
+      @env.select { |k, _v| k.start_with? 'HTTP_' } || []
+    end
+
+    private
+
+    def read_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/storage.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  class Storage
+    class << self
+      def configuration
+        @configuration ||= new
+      end
+
+      def configure
+        yield(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
+
+    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/tracers.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RailsMiniProfiler
+  class Tracers
+    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
+
+      def build_trace(event)
+        start = (event.time.to_f * 100_000).to_i
+        finish = (event.end.to_f * 100_000).to_i
+        Models::Trace.new(
+          name: event.name,
+          start: start,
+          finish: finish,
+          duration: finish - start,
+          allocations: event.allocations,
+          backtrace: Rails.backtrace_cleaner.clean(caller),
+          payload: format_payload(event)
+        )
+      end
+
+      private
+
+      def subscribe(*subscriptions, &callback)
+        subscriptions.each do |subscription|
+          ActiveSupport::Notifications.subscribe(subscription) do |event|
+            callback.call(event)
+          end
+        end
+      end
+
+      def format_payload(event)
+        case event.name
+        when 'sql.active_record'
+          transform_sql_event(event)
+        when 'render_template.action_view', 'render_partial.action_view'
+          event.payload.slice(:identifier, :count)
+        when 'process_action.action_controller'
+          transform_controller_event(event)
+        else
+          event.payload
+        end
+      end
+
+      def transform_sql_event(event)
+        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.respond_to?(:call) ? typecasted_binds.call : typecasted_binds
+        payload[:binds] = transform_binds(payload[:binds], typecasted_binds)
+        payload.delete(:type_casted_binds)
+        payload.reject { |_k, v| v.blank? }
+      end
+
+      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 transform_controller_event(event)
+        payload = event.payload
+                    .slice(:view_runtime, :db_runtime)
+                    .transform_values { |value| value&.round(2) }
+        payload.reject { |_k, v| v.blank? }
+      end
+    end
+  end
+end