rails-profiler 0.1.4

data/app/controllers/profiler/api/ajax_controller.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Api
+    class AjaxController < ApplicationController
+      skip_before_action :verify_authenticity_token, only: [:link]
+
+      def link
+        parent_token = params[:parent_token]
+        child_token = params[:child_token]
+
+        # Validate parameters
+        if parent_token.blank? || child_token.blank?
+          return render json: { error: "Missing parent_token or child_token" }, status: :bad_request
+        end
+
+        # Load child profile
+        child_profile = Profiler.storage.load(child_token)
+        unless child_profile
+          return render json: { error: "Child profile not found" }, status: :not_found
+        end
+
+        # Set parent relationship
+        child_profile.parent_token = parent_token
+        child_profile.is_ajax = true
+
+        # Save updated profile
+        Profiler.storage.save(child_token, child_profile)
+
+        render json: { success: true }
+      rescue => e
+        render json: { error: e.message }, status: :internal_server_error
+      end
+    end
+  end
+end

data/app/controllers/profiler/api/jobs_controller.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Api
+    class JobsController < ApplicationController
+      skip_before_action :verify_authenticity_token
+
+      def index
+        all_profiles = Profiler.storage.list(limit: (params[:limit] || 200).to_i, offset: (params[:offset] || 0).to_i)
+        job_profiles = all_profiles.select { |p| p.profile_type == "job" }
+        job_profiles = job_profiles.first((params[:limit] || 50).to_i)
+        render json: job_profiles.map(&:to_h)
+      end
+
+      def show
+        profile = Profiler.storage.load(params[:id])
+
+        unless profile && profile.profile_type == "job"
+          return render json: { error: "Job profile not found" }, status: :not_found
+        end
+
+        render json: profile.to_h
+      end
+
+      def destroy
+        profile = Profiler.storage.load(params[:id])
+        return render json: { error: "Job profile not found" }, status: :not_found unless profile&.profile_type == "job"
+
+        Profiler.storage.delete(params[:id])
+        head :no_content
+      end
+
+      def clear
+        Profiler.storage.clear(type: "job")
+        head :no_content
+      end
+    end
+  end
+end

data/app/controllers/profiler/api/outbound_http_controller.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Api
+    class OutboundHttpController < ApplicationController
+      skip_before_action :verify_authenticity_token
+
+      # GET /_profiler/api/outbound_http
+      def index
+        limit = (params[:limit] || 200).to_i
+        profiles = Profiler.storage.list(limit: limit)
+
+        requests = profiles.flat_map do |profile|
+          http_data = profile.collector_data("http")
+          next [] unless http_data && http_data["requests"]&.any?
+
+          http_data["requests"]
+            .reject { |req| profiler_url?(req["url"].to_s) }
+            .map { |req| req.merge("profile_token" => profile.token, "profile_started_at" => profile.started_at) }
+        end
+
+        requests.sort_by! { |r| r["profile_started_at"] }.reverse!
+
+        render json: requests
+      end
+
+      private
+
+      def profiler_url?(url)
+        URI.parse(url).path.start_with?("/_profiler")
+      rescue URI::InvalidURIError
+        false
+      end
+    end
+  end
+end

data/app/controllers/profiler/api/profiles_controller.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Api
+    class ProfilesController < ApplicationController
+      skip_before_action :verify_authenticity_token
+
+      def index
+        profiles = Profiler.storage.list(limit: params[:limit] || 50, offset: params[:offset] || 0)
+        render json: profiles.map(&:to_h)
+      end
+
+      def show
+        profile = Profiler.storage.load(params[:id])
+
+        unless profile
+          return render json: { error: "Profile not found" }, status: :not_found
+        end
+
+        # Recalculate AJAX collector data (since AJAX requests happen after page load)
+        recalculate_ajax_data(profile)
+
+        render json: profile.to_h
+      end
+
+      def destroy
+        profile = Profiler.storage.load(params[:id])
+        return render json: { error: "Profile not found" }, status: :not_found unless profile
+
+        Profiler.storage.delete(params[:id])
+        head :no_content
+      end
+
+      def clear
+        Profiler.storage.clear(type: "http")
+        head :no_content
+      end
+
+      private
+
+      def recalculate_ajax_data(profile)
+        # Find AJAX collector in the configured collectors
+        ajax_collector_class = Profiler::Collectors::AjaxCollector
+
+        if Profiler.configuration.collectors.include?(ajax_collector_class)
+          collector = ajax_collector_class.new(profile)
+          collector.collect
+
+          # Update tab metadata to reflect has_data status
+          if profile.instance_variable_get(:@collectors_metadata)
+            ajax_tab = profile.instance_variable_get(:@collectors_metadata).find { |tab| tab[:key] == 'ajax' }
+            if ajax_tab
+              ajax_tab[:has_data] = collector.has_data?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/profiler/api/toolbar_controller.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Api
+    class ToolbarController < Profiler::ApplicationController
+      skip_before_action :verify_authenticity_token
+      skip_before_action :check_authorization
+
+      def show
+        profile = Profiler.storage.load(params[:token])
+
+        unless profile
+          render json: { error: "Profile not found" }, status: :not_found
+          return
+        end
+
+        # Recalculate AJAX collector data (since AJAX requests happen after page load)
+        recalculate_ajax_data(profile)
+
+        render json: { profile: profile.to_h }
+      end
+
+      private
+
+      def recalculate_ajax_data(profile)
+        # Find AJAX collector in the configured collectors
+        ajax_collector_class = Profiler::Collectors::AjaxCollector
+
+        if Profiler.configuration.collectors.include?(ajax_collector_class)
+          collector = ajax_collector_class.new(profile)
+          collector.collect
+
+          # Update tab metadata to reflect has_data status
+          if profile.instance_variable_get(:@collectors_metadata)
+            ajax_tab = profile.instance_variable_get(:@collectors_metadata).find { |tab| tab[:key] == 'ajax' }
+            if ajax_tab
+              ajax_tab[:has_data] = collector.has_data?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/profiler/application_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Profiler
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    layout "profiler/application"
+
+    before_action :check_authorization
+
+    private
+
+    def check_authorization
+      unless Profiler.configuration.enabled
+        render plain: "Profiler is disabled", status: :forbidden
+      end
+    end
+  end
+end

data/app/controllers/profiler/assets_controller.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Profiler
+  class AssetsController < ApplicationController
+    skip_before_action :verify_authenticity_token
+    skip_before_action :check_authorization
+
+    def toolbar_js
+      path = Profiler::Engine.root.join("app", "assets", "builds", "profiler-toolbar.js")
+      js = File.read(path)
+      expires_in 1.hour, public: true
+      render plain: js, content_type: "application/javascript"
+    end
+
+    def main_js
+      path = Profiler::Engine.root.join("app", "assets", "builds", "profiler.js")
+      js = File.read(path)
+      expires_in 1.hour, public: true
+      render plain: js, content_type: "application/javascript"
+    end
+
+    def main_css
+      path = Profiler::Engine.root.join("app", "assets", "builds", "profiler.css")
+      css = File.read(path)
+      expires_in 1.hour, public: true
+      render plain: css, content_type: "text/css"
+    end
+  end
+end

data/app/controllers/profiler/profiles_controller.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Profiler
+  class ProfilesController < ApplicationController
+    before_action :allow_iframe_embedding, only: [:show], if: -> { params[:embed] == "true" }
+
+    def index
+      limit = params[:limit]&.to_i || 50
+      offset = params[:offset]&.to_i || 0
+
+      @profiles = Profiler.storage.list(limit: limit, offset: offset)
+      @profiles = filter_profiles(@profiles) if params[:filter].present?
+    end
+
+    def show
+      @profile = Profiler.storage.load(params[:id])
+
+      unless @profile
+        render plain: "Profile not found", status: :not_found
+        return
+      end
+
+      # Recalculate AJAX collector data (since AJAX requests happen after page load)
+      recalculate_ajax_data(@profile)
+
+      @embedded = params[:embed] == "true"
+
+      render layout: @embedded ? "profiler/embedded" : "profiler/application"
+    end
+
+    def timeline
+      @profile = Profiler.storage.load(params[:id])
+      render json: @profile.collector_data("performance")
+    end
+
+    def database
+      @profile = Profiler.storage.load(params[:id])
+      render json: @profile.collector_data("database")
+    end
+
+    def views
+      @profile = Profiler.storage.load(params[:id])
+      render json: @profile.collector_data("view")
+    end
+
+    def cache
+      @profile = Profiler.storage.load(params[:id])
+      render json: @profile.collector_data("cache")
+    end
+
+    def performance
+      @profile = Profiler.storage.load(params[:id])
+      render json: @profile.collector_data("performance")
+    end
+
+    def flamegraph
+      @profile = Profiler.storage.load(params[:id])
+      render json: @profile.collector_data("flamegraph")
+    end
+
+    private
+
+    def recalculate_ajax_data(profile)
+      # Find AJAX collector in the configured collectors
+      ajax_collector_class = Profiler::Collectors::AjaxCollector
+
+      if Profiler.configuration.collectors.include?(ajax_collector_class)
+        collector = ajax_collector_class.new(profile)
+        collector.collect
+
+        # Update tab metadata to reflect has_data status
+        if profile.instance_variable_get(:@collectors_metadata)
+          ajax_tab = profile.instance_variable_get(:@collectors_metadata).find { |tab| tab[:key] == 'ajax' }
+          if ajax_tab
+            ajax_tab[:has_data] = collector.has_data?
+          end
+        end
+      end
+    end
+
+    def allow_iframe_embedding
+      response.headers.delete('X-Frame-Options')
+      # Don't set frame-ancestors CSP to allow Chrome extensions to embed
+      # Mark that CSP should not be set by middleware
+      request.env['profiler.skip_csp'] = true
+    end
+
+    def filter_profiles(profiles)
+      filtered = profiles
+
+      if params[:filter][:path].present?
+        filtered = filtered.select { |p| p.path.include?(params[:filter][:path]) }
+      end
+
+      if params[:filter][:method].present?
+        filtered = filtered.select { |p| p.method == params[:filter][:method] }
+      end
+
+      if params[:filter][:min_duration].present?
+        min = params[:filter][:min_duration].to_f
+        filtered = filtered.select { |p| p.duration >= min }
+      end
+
+      filtered
+    end
+  end
+end

data/app/views/layouts/profiler/application.html.erb

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Rails Profiler</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+
+    <link rel="stylesheet" href="/_profiler/assets/profiler.css">
+    <script src="/_profiler/assets/profiler.js" defer></script>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/app/views/layouts/profiler/embedded.html.erb

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html data-theme="<%= params[:theme].presence&.then { |t| %w[light dark].include?(t) ? t : 'dark' } || 'dark' %>">
+<head>
+  <title>Rails Profiler</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <link rel="stylesheet" href="/_profiler/assets/profiler.css">
+  <script src="/_profiler/assets/profiler.js" defer></script>
+
+  <style>
+    /* Embedded overrides — tighter layout, no page chrome */
+    body { overflow-y: auto; }
+    .container { padding: 16px 20px; }
+  </style>
+
+  <script>
+    // Receive theme changes from the Chrome extension panel via postMessage.
+    // The extension sends: { type: 'profiler:set-theme', theme: 'light' | 'dark' }
+    window.addEventListener('message', function(e) {
+      var data = e.data;
+      if (data && data.type === 'profiler:set-theme' &&
+          (data.theme === 'light' || data.theme === 'dark')) {
+        document.documentElement.setAttribute('data-theme', data.theme);
+      }
+    });
+  </script>
+</head>
+
+<body>
+  <%= yield %>
+</body>
+</html>

data/app/views/profiler/profiles/index.html.erb

@@ -0,0 +1 @@
+<div id="profiler-index"></div>

data/app/views/profiler/profiles/show.html.erb

@@ -0,0 +1,4 @@
+<div id="profiler-show" data-embedded="<%= @embedded %>"></div>
+<script type="application/json" id="profiler-show-data">
+  <%= @profile.to_json.html_safe %>
+</script>

data/config/routes.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "profiler/mcp/server"
+
+Profiler::Engine.routes.draw do
+  mount Profiler::MCP::Server.rack_app, at: "mcp"
+
+  root to: "profiles#index"
+
+  resources :profiles, only: [:index, :show] do
+    member do
+      get :timeline
+      get :database
+      get :views
+      get :cache
+      get :performance
+      get :flamegraph
+    end
+  end
+
+  get "assets/profiler-toolbar.js", to: "assets#toolbar_js"
+  get "assets/profiler.js", to: "assets#main_js"
+  get "assets/profiler.css", to: "assets#main_css"
+
+  namespace :api do
+    resources :profiles, only: [:index, :show, :destroy] do
+      collection { delete :clear }
+    end
+    resources :jobs, only: [:index, :show, :destroy] do
+      collection { delete :clear }
+    end
+    resources :outbound_http, only: [:index]
+    get "toolbar/:token", to: "toolbar#show"
+    post "ajax/link", to: "ajax#link"
+  end
+end

data/exe/profiler-mcp

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "profiler"
+require "profiler/mcp/server"
+
+Profiler::MCP::Server.new.start(transport: :stdio)

data/lib/profiler/collectors/ajax_collector.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "base_collector"
+
+module Profiler
+  module Collectors
+    class AjaxCollector < BaseCollector
+      def icon
+        "🌐"
+      end
+
+      def priority
+        25
+      end
+
+      def tab_config
+        {
+          key: "ajax",
+          label: "AJAX",
+          icon: icon,
+          priority: priority,
+          enabled: true,
+          default_active: false
+        }
+      end
+
+      def subscribe
+        # Passive collector - no subscriptions needed
+      end
+
+      def collect
+        # Query storage for child AJAX profiles
+        ajax_profiles = Profiler.storage.find_by_parent(@profile.token)
+
+        return store_data({}) if ajax_profiles.empty?
+
+        # Generate summary statistics
+        data = {
+          "total_requests" => ajax_profiles.size,
+          "total_duration" => ajax_profiles.sum(&:duration).round(2),
+          "by_method" => group_by_method(ajax_profiles),
+          "by_status" => group_by_status(ajax_profiles),
+          "requests" => ajax_profiles.map { |p| request_summary(p) }
+        }
+
+        store_data(data)
+      end
+
+      def toolbar_summary
+        return "" unless @data && @data["total_requests"]&.positive?
+
+        total = @data["total_requests"]
+        duration = @data["total_duration"]
+
+        # Color coding based on number of requests
+        color = if total > 20
+                  "orange"
+                elsif total > 50
+                  "red"
+                else
+                  "green"
+                end
+
+        {
+          text: "#{total} AJAX (#{duration}ms)",
+          color: color
+        }
+      end
+
+      private
+
+      def group_by_method(profiles)
+        profiles.group_by(&:method).transform_values(&:count)
+      end
+
+      def group_by_status(profiles)
+        profiles.group_by { |p| status_category(p.status) }.transform_values(&:count)
+      end
+
+      def status_category(status)
+        return "unknown" unless status
+
+        case status
+        when 200..299
+          "2xx"
+        when 300..399
+          "3xx"
+        when 400..499
+          "4xx"
+        when 500..599
+          "5xx"
+        else
+          "other"
+        end
+      end
+
+      def request_summary(profile)
+        {
+          "token" => profile.token,
+          "path" => profile.path,
+          "method" => profile.method,
+          "status" => profile.status,
+          "duration" => profile.duration,
+          "started_at" => profile.started_at&.iso8601
+        }
+      end
+    end
+  end
+end

data/lib/profiler/collectors/base_collector.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Collectors
+    class BaseCollector
+      attr_reader :profile
+
+      def initialize(profile)
+        @profile = profile
+        @data = {}
+      end
+
+      def name
+        self.class.name.split("::").last.gsub("Collector", "").downcase
+      end
+
+      def icon
+        "📊"
+      end
+
+      def priority
+        100
+      end
+
+      # Tab configuration for dynamic tab system
+      def tab_config
+        {
+          key: name,
+          label: name.capitalize,
+          icon: icon,
+          priority: priority,
+          enabled: true,
+          default_active: false
+        }
+      end
+
+      # How to render the tab: :auto (use JSON), :custom (call render_html), :client (frontend renderer)
+      def render_mode
+        :auto
+      end
+
+      # For custom HTML rendering from backend (when render_mode is :custom)
+      def render_html(profile)
+        nil
+      end
+
+      # Whether this collector has data for the current profile
+      def has_data?
+        data = panel_content
+        return false if data.nil?
+        return false if data.is_a?(Hash) && data.empty?
+        return false if data.is_a?(Array) && data.empty?
+        true
+      end
+
+      def subscribe
+        # Override in subclasses to subscribe to ActiveSupport::Notifications
+      end
+
+      def collect
+        # Override in subclasses to collect data
+      end
+
+      def toolbar_summary
+        # Override in subclasses to provide summary for toolbar
+        ""
+      end
+
+      def panel_content
+        # Override in subclasses to provide full panel content
+        @data
+      end
+
+      def self.inherited(subclass)
+        super
+        # Auto-register collectors
+        (@descendants ||= []) << subclass
+      end
+
+      def self.descendants
+        @descendants || []
+      end
+
+      protected
+
+      def store_data(data)
+        @data = data
+        @profile.add_collector_data(name, data)
+      end
+    end
+  end
+end