brainzlab 0.1.1 → 0.1.3

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] || {}
+            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,177 @@
+# 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)
+          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 StandardError => e
+          json_response({ success: false, output: "Error: #{e.message}\n\n#{e.backtrace&.first(10)&.join("\n")}" })
+        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 StandardError => 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) }
+          output.puts ''
+          if pending.any?
+            output.puts "#{pending.count} pending migration(s)"
+          else
+            output.puts 'All migrations are up to date!'
+          end
+
+          { success: true, output: output.string }
+        rescue StandardError => 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 StandardError => 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 StandardError => 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>
+          full_body = if full_body.include?('</body>')
+                        full_body.sub('</body>', "#{panel_html}</body>")
+                      else
+                        # If no </body> tag, append at the end
+                        "#{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