brainzlab 0.1.1 → 0.1.2

data/lib/brainzlab/devtools/data/collector.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module DevTools
+    module Data
+      class Collector
+        THREAD_KEY = :brainzlab_devtools_data
+
+        class << self
+          def start_request(env)
+            Thread.current[THREAD_KEY] = {
+              started_at: Time.now.utc,
+              sql_queries: [],
+              views: [],
+              logs: [],
+              memory_before: get_memory_usage,
+              env: env
+            }
+
+            subscribe_to_events
+          end
+
+          def end_request
+            unsubscribe_from_events
+            data = Thread.current[THREAD_KEY]
+            Thread.current[THREAD_KEY] = nil
+            data
+          end
+
+          def active?
+            !Thread.current[THREAD_KEY].nil?
+          end
+
+          def get_request_data
+            data = Thread.current[THREAD_KEY] || {}
+            return {} if data.empty?
+
+            context = defined?(BrainzLab::Context) ? BrainzLab::Context.current : nil
+            duration_ms = data[:started_at] ? ((Time.now.utc - data[:started_at]) * 1000).round(2) : 0
+
+            {
+              timing: {
+                started_at: data[:started_at],
+                duration_ms: duration_ms
+              },
+              request: build_request_data(data, context),
+              controller: build_controller_data(context),
+              database: build_database_data(data[:sql_queries] || []),
+              views: build_views_data(data[:views] || []),
+              logs: data[:logs] || [],
+              memory: build_memory_data(data),
+              user: context&.user,
+              breadcrumbs: context&.breadcrumbs&.to_a || []
+            }
+          end
+
+          def add_sql_query(name:, duration:, sql:, cached: false, source: nil)
+            data = Thread.current[THREAD_KEY]
+            return unless data
+
+            data[:sql_queries] << {
+              name: name,
+              duration: duration.round(2),
+              sql: sql,
+              sql_pattern: normalize_sql(sql),
+              cached: cached,
+              source: source,
+              timestamp: Time.now.utc
+            }
+          end
+
+          def add_view(type:, template:, duration:, layout: nil)
+            data = Thread.current[THREAD_KEY]
+            return unless data
+
+            data[:views] << {
+              type: type,
+              template: template,
+              duration: duration.round(2),
+              layout: layout,
+              timestamp: Time.now.utc
+            }
+          end
+
+          def add_log(level:, message:, log_data: nil)
+            request_data = Thread.current[THREAD_KEY]
+            return unless request_data
+
+            request_data[:logs] << {
+              level: level,
+              message: message,
+              data: log_data,
+              timestamp: Time.now.utc
+            }
+          end
+
+          private
+
+          def build_request_data(data, context)
+            env = data[:env] || {}
+            request = env["action_dispatch.request"] || (defined?(ActionDispatch::Request) ? ActionDispatch::Request.new(env) : nil)
+
+            {
+              method: context&.request_method || env["REQUEST_METHOD"],
+              path: context&.request_path || env["PATH_INFO"],
+              url: context&.request_url || env["REQUEST_URI"],
+              params: context&.request_params || {},
+              headers: extract_headers(env),
+              request_id: context&.request_id || env["action_dispatch.request_id"]
+            }
+          end
+
+          def build_controller_data(context)
+            {
+              name: context&.controller,
+              action: context&.action
+            }
+          end
+
+          def build_database_data(queries)
+            {
+              queries: queries,
+              total_count: queries.length,
+              cached_count: queries.count { |q| q[:cached] },
+              total_duration_ms: queries.sum { |q| q[:duration] || 0 }.round(2),
+              n_plus_ones: detect_n_plus_ones(queries)
+            }
+          end
+
+          def build_views_data(views)
+            {
+              templates: views,
+              total_count: views.length,
+              total_duration_ms: views.sum { |v| v[:duration] || 0 }.round(2)
+            }
+          end
+
+          def build_memory_data(data)
+            current_memory = get_memory_usage
+            before_memory = data[:memory_before] || 0
+
+            {
+              before_mb: before_memory,
+              after_mb: current_memory,
+              delta_mb: (current_memory - before_memory).round(2)
+            }
+          end
+
+          def extract_headers(env)
+            headers = {}
+            env.each do |key, value|
+              if key.start_with?("HTTP_")
+                header_name = key.sub("HTTP_", "").split("_").map(&:capitalize).join("-")
+                headers[header_name] = value
+              end
+            end
+            headers
+          end
+
+          def subscribe_to_events
+            return unless defined?(ActiveSupport::Notifications)
+
+            @sql_subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+              event = ActiveSupport::Notifications::Event.new(*args)
+              next if event.payload[:name] == "SCHEMA"
+              next if event.payload[:sql]&.start_with?("PRAGMA")
+
+              add_sql_query(
+                name: event.payload[:name],
+                duration: event.duration,
+                sql: event.payload[:sql],
+                cached: event.payload[:cached] || event.payload[:name] == "CACHE",
+                source: extract_source(caller)
+              )
+            end
+
+            @view_subscriber = ActiveSupport::Notifications.subscribe(/render_.+\.action_view/) do |*args|
+              event = ActiveSupport::Notifications::Event.new(*args)
+              type = event.name.include?("partial") ? :partial : :template
+
+              add_view(
+                type: type,
+                template: event.payload[:identifier],
+                duration: event.duration,
+                layout: event.payload[:layout]
+              )
+            end
+          end
+
+          def unsubscribe_from_events
+            return unless defined?(ActiveSupport::Notifications)
+
+            ActiveSupport::Notifications.unsubscribe(@sql_subscriber) if @sql_subscriber
+            ActiveSupport::Notifications.unsubscribe(@view_subscriber) if @view_subscriber
+            @sql_subscriber = nil
+            @view_subscriber = nil
+          end
+
+          def detect_n_plus_ones(queries)
+            non_cached = queries.reject { |q| q[:cached] }
+            pattern_groups = non_cached.group_by { |q| q[:sql_pattern] }
+
+            pattern_groups.select { |_, qs| qs.size >= 3 }.map do |pattern, matching|
+              {
+                pattern: pattern,
+                count: matching.size,
+                total_duration_ms: matching.sum { |q| q[:duration] || 0 }.round(2),
+                sample_query: matching.first[:sql],
+                source: matching.first[:source]
+              }
+            end
+          end
+
+          def normalize_sql(sql)
+            return nil unless sql
+
+            sql.gsub(/\b\d+\b/, "?")
+               .gsub(/'[^']*'/, "?")
+               .gsub(/\$\d+/, "?")
+               .gsub(%r{/\*.*?\*/}, "")
+               .gsub(/\s+/, " ")
+               .strip
+          end
+
+          def get_memory_usage
+            `ps -o rss= -p #{Process.pid}`.to_i / 1024.0
+          rescue StandardError
+            0
+          end
+
+          def extract_source(backtrace)
+            backtrace.each do |line|
+              next if line.include?("/brainzlab")
+              next if line.include?("/gems/")
+              next if line.include?("/ruby/")
+
+              if line.include?("/app/")
+                match = line.match(%r{(app/[^:]+:\d+)})
+                return match[1] if match
+              end
+            end
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/devtools/middleware/asset_server.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module DevTools
+    module Middleware
+      class AssetServer
+        MIME_TYPES = {
+          ".css" => "text/css; charset=utf-8",
+          ".js" => "application/javascript; charset=utf-8",
+          ".svg" => "image/svg+xml",
+          ".png" => "image/png",
+          ".woff2" => "font/woff2"
+        }.freeze
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          return @app.call(env) unless DevTools.enabled?
+
+          path = env["PATH_INFO"]
+          asset_prefix = DevTools.asset_path
+
+          if path.start_with?("#{asset_prefix}/")
+            serve_asset(path.sub("#{asset_prefix}/", ""))
+          else
+            @app.call(env)
+          end
+        end
+
+        private
+
+        def serve_asset(relative_path)
+          # Prevent directory traversal
+          return not_found if relative_path.include?("..")
+
+          file_path = File.join(DevTools::ASSETS_PATH, relative_path)
+          return not_found unless File.exist?(file_path)
+
+          ext = File.extname(relative_path)
+          content_type = MIME_TYPES[ext] || "application/octet-stream"
+          content = File.read(file_path)
+
+          [
+            200,
+            {
+              "Content-Type" => content_type,
+              "Content-Length" => content.bytesize.to_s,
+              "Cache-Control" => "public, max-age=31536000",
+              "X-Content-Type-Options" => "nosniff"
+            },
+            [content]
+          ]
+        end
+
+        def not_found
+          [404, { "Content-Type" => "text/plain" }, ["Not Found"]]
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/devtools/middleware/database_handler.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module DevTools
+    module Middleware
+      class DatabaseHandler
+        ENDPOINT = "/_brainzlab/devtools/database"
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          return @app.call(env) unless should_handle?(env)
+
+          handle_database_request(env)
+        end
+
+        private
+
+        def should_handle?(env)
+          return false unless DevTools.enabled?
+          return false unless DevTools.allowed_environment?
+          return false unless DevTools.allowed_ip?(extract_ip(env))
+          return false unless env["PATH_INFO"] == ENDPOINT
+          return false unless env["REQUEST_METHOD"] == "POST"
+
+          true
+        end
+
+        def extract_ip(env)
+          forwarded = env["HTTP_X_FORWARDED_FOR"]
+          return forwarded.split(",").first.strip if forwarded
+
+          env["REMOTE_ADDR"]
+        end
+
+        def handle_database_request(env)
+          begin
+            body = env["rack.input"].read
+            env["rack.input"].rewind
+            params = JSON.parse(body)
+            action = params["action"]
+
+            result = case action
+            when "migrate"
+              run_migrations
+            when "status"
+              migration_status
+            when "create"
+              create_database
+            when "rollback"
+              rollback_migration
+            else
+              { success: false, output: "Unknown action: #{action}" }
+            end
+
+            json_response(result)
+          rescue => e
+            json_response({ success: false, output: "Error: #{e.message}\n\n#{e.backtrace&.first(10)&.join("\n")}" })
+          end
+        end
+
+        def run_migrations
+          return not_available("Rails") unless defined?(Rails)
+
+          output = capture_output do
+            ActiveRecord::MigrationContext.new(
+              Rails.root.join("db/migrate"),
+              ActiveRecord::SchemaMigration
+            ).migrate
+          end
+
+          { success: true, output: output.presence || "All migrations completed successfully!" }
+        rescue => e
+          { success: false, output: "Migration failed:\n#{e.message}\n\n#{e.backtrace&.first(10)&.join("\n")}" }
+        end
+
+        def migration_status
+          return not_available("Rails") unless defined?(Rails)
+
+          output = StringIO.new
+
+          context = ActiveRecord::MigrationContext.new(
+            Rails.root.join("db/migrate"),
+            ActiveRecord::SchemaMigration
+          )
+
+          migrated = context.get_all_versions.to_set
+          migrations = context.migrations
+
+          output.puts "database: #{ActiveRecord::Base.connection_db_config.database}"
+          output.puts ""
+          output.puts " Status   Migration ID    Migration Name"
+          output.puts "-" * 60
+
+          migrations.each do |migration|
+            status = migrated.include?(migration.version) ? "   up" : " down"
+            output.puts " #{status}     #{migration.version}  #{migration.name}"
+          end
+
+          pending = migrations.reject { |m| migrated.include?(m.version) }
+          if pending.any?
+            output.puts ""
+            output.puts "#{pending.count} pending migration(s)"
+          else
+            output.puts ""
+            output.puts "All migrations are up to date!"
+          end
+
+          { success: true, output: output.string }
+        rescue => e
+          { success: false, output: "Failed to check status:\n#{e.message}" }
+        end
+
+        def create_database
+          return not_available("Rails") unless defined?(Rails)
+
+          output = capture_output do
+            ActiveRecord::Tasks::DatabaseTasks.create_current
+          end
+
+          { success: true, output: output.presence || "Database created successfully!" }
+        rescue ActiveRecord::DatabaseAlreadyExists
+          { success: true, output: "Database already exists." }
+        rescue => e
+          { success: false, output: "Failed to create database:\n#{e.message}" }
+        end
+
+        def rollback_migration
+          return not_available("Rails") unless defined?(Rails)
+
+          output = capture_output do
+            ActiveRecord::MigrationContext.new(
+              Rails.root.join("db/migrate"),
+              ActiveRecord::SchemaMigration
+            ).rollback
+          end
+
+          { success: true, output: output.presence || "Rollback completed!" }
+        rescue => e
+          { success: false, output: "Rollback failed:\n#{e.message}" }
+        end
+
+        def capture_output
+          original_stdout = $stdout
+          original_stderr = $stderr
+          captured = StringIO.new
+          $stdout = captured
+          $stderr = captured
+
+          yield
+
+          captured.string
+        ensure
+          $stdout = original_stdout
+          $stderr = original_stderr
+        end
+
+        def not_available(framework)
+          { success: false, output: "#{framework} is not available." }
+        end
+
+        def json_response(data)
+          body = JSON.generate(data)
+          [
+            200,
+            {
+              "Content-Type" => "application/json; charset=utf-8",
+              "Content-Length" => body.bytesize.to_s,
+              "Cache-Control" => "no-store",
+              "X-Content-Type-Options" => "nosniff"
+            },
+            [body]
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/devtools/middleware/debug_panel.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module DevTools
+    module Middleware
+      class DebugPanel
+        HTML_CONTENT_TYPE = "text/html"
+
+        def initialize(app)
+          @app = app
+          @renderer = Renderers::DebugPanelRenderer.new
+        end
+
+        def call(env)
+          return @app.call(env) unless should_inject?(env)
+
+          # Start collecting data
+          Data::Collector.start_request(env)
+
+          begin
+            status, headers, body = @app.call(env)
+
+            # Only inject into HTML responses
+            if injectable_response?(status, headers)
+              body = inject_panel(body, env, status, headers)
+              headers = update_content_length(headers, body)
+            end
+
+            [status, headers, body]
+          ensure
+            Data::Collector.end_request
+          end
+        end
+
+        private
+
+        def should_inject?(env)
+          return false unless DevTools.debug_panel_enabled?
+          return false unless DevTools.allowed_environment?
+          return false unless DevTools.allowed_ip?(extract_ip(env))
+          return false if asset_request?(env["PATH_INFO"])
+          return false if devtools_asset_request?(env["PATH_INFO"])
+          return false if turbo_stream_request?(env)
+
+          true
+        end
+
+        def extract_ip(env)
+          forwarded = env["HTTP_X_FORWARDED_FOR"]
+          return forwarded.split(",").first.strip if forwarded
+
+          env["REMOTE_ADDR"]
+        end
+
+        def injectable_response?(status, headers)
+          return false unless status == 200
+
+          content_type = headers["Content-Type"]
+          return false unless content_type
+
+          content_type.include?(HTML_CONTENT_TYPE)
+        end
+
+        def asset_request?(path)
+          return true if path.nil?
+
+          asset_paths = %w[/assets /packs /vite]
+          asset_extensions = %w[.js .css .map .png .jpg .jpeg .gif .svg .ico .woff .woff2 .ttf .eot]
+
+          asset_paths.any? { |p| path.start_with?(p) } ||
+            asset_extensions.any? { |ext| path.end_with?(ext) }
+        end
+
+        def devtools_asset_request?(path)
+          return false if path.nil?
+
+          path.start_with?(DevTools.asset_path)
+        end
+
+        def turbo_stream_request?(env)
+          accept = env["HTTP_ACCEPT"] || ""
+          accept.include?("text/vnd.turbo-stream.html")
+        end
+
+        def inject_panel(body, env, status, headers)
+          # Collect all response body parts
+          full_body = collect_body(body)
+
+          # Get collected data
+          data = Data::Collector.get_request_data
+          data[:response] = {
+            status: status,
+            headers: headers.to_h,
+            content_type: headers["Content-Type"]
+          }
+
+          # Render panel HTML
+          panel_html = @renderer.render(data)
+
+          # Inject before </body>
+          if full_body.include?("</body>")
+            full_body = full_body.sub("</body>", "#{panel_html}</body>")
+          else
+            # If no </body> tag, append at the end
+            full_body = "#{full_body}#{panel_html}"
+          end
+
+          [full_body]
+        end
+
+        def collect_body(body)
+          full_body = +""
+          body.each { |part| full_body << part }
+          body.close if body.respond_to?(:close)
+          full_body
+        end
+
+        def update_content_length(headers, body)
+          headers = headers.to_h.dup
+          headers["Content-Length"] = body.sum(&:bytesize).to_s
+          headers
+        end
+      end
+    end
+  end
+end