brainzlab 0.1.1 → 0.1.3

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

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module DevTools
+    module Middleware
+      class ErrorPage
+        def initialize(app)
+          @app = app
+          @renderer = Renderers::ErrorPageRenderer.new
+        end
+
+        def call(env)
+          return @app.call(env) unless should_handle?(env)
+
+          begin
+            status, headers, body = @app.call(env)
+
+            # Check if this is an error response that we should intercept
+            if status >= 400 && html_response?(headers) && !json_request?(env)
+              # Check if this looks like Rails' default error page
+              body_content = collect_body(body)
+              if body_content.include?('Action Controller: Exception caught') || body_content.include?('background: #C00')
+                # Extract exception info from the page
+                exception_info = extract_exception_from_html(body_content)
+                if exception_info
+                  data = collect_debug_data_from_info(env, exception_info)
+                  return render_error_page_from_info(exception_info, data)
+                end
+              end
+            end
+
+            [status, headers, body]
+          rescue Exception => e
+            # Don't intercept if request wants JSON
+            return raise_exception(e) if json_request?(env)
+
+            # Still capture to Reflex if available
+            capture_to_reflex(e)
+
+            # Collect debug data and render branded error page
+            data = collect_debug_data(env, e)
+            render_error_page(e, data)
+          end
+        end
+
+        def html_response?(headers)
+          # Handle both uppercase and lowercase header names
+          content_type = headers['Content-Type'] || headers['content-type'] || ''
+          content_type.to_s.downcase.include?('text/html')
+        end
+
+        def extract_exception_from_html(body)
+          # Try to extract exception class and message from Rails error page
+          if (match = body.match(%r{<h1>([^<]+)</h1>}))
+            error_title = match[1]
+            # Extract the exception message from the page
+            if (msg_match = body.match(%r{<pre[^>]*>([^<]+)</pre>}))
+              error_message = msg_match[1]
+            end
+
+            # Try to extract backtrace from Rails 8 format
+            # Format: <a class="trace-frames ...">path/to/file.rb:123:in 'method'</a>
+            backtrace = []
+            body.scan(%r{<a[^>]*class="trace-frames[^"]*"[^>]*>\s*([^<]+)\s*</a>}m) do |trace_match|
+              line = trace_match[0].strip
+              # Decode HTML entities
+              line = line.gsub('&#39;', "'").gsub('&quot;', '"').gsub('&amp;', '&').gsub('&lt;', '<').gsub('&gt;', '>')
+              backtrace << line unless line.empty?
+            end
+
+            {
+              class_name: decode_html_entities(error_title.strip),
+              message: decode_html_entities(error_message&.strip || error_title.strip),
+              backtrace: backtrace
+            }
+          end
+        end
+
+        def decode_html_entities(str)
+          return str unless str
+
+          str.gsub('&#39;', "'")
+             .gsub('&quot;', '"')
+             .gsub('&amp;', '&')
+             .gsub('&lt;', '<')
+             .gsub('&gt;', '>')
+             .gsub('&nbsp;', ' ')
+        end
+
+        def collect_debug_data_from_info(env, info)
+          context = defined?(BrainzLab::Context) ? BrainzLab::Context.current : nil
+          collector_data = Data::Collector.get_request_data
+
+          backtrace = (info[:backtrace] || []).map do |line|
+            parsed = parse_backtrace_line(line)
+            parsed[:in_app] = in_app_frame?(parsed[:file])
+            parsed
+          end
+
+          # Extract source from the first in-app frame
+          source_extract = extract_source_from_backtrace(info[:backtrace] || [])
+
+          {
+            exception: nil,
+            exception_class: info[:class_name],
+            exception_message: info[:message],
+            backtrace: backtrace,
+            request: build_request_info(env, context),
+            context: build_context_info(context),
+            sql_queries: collector_data.dig(:database, :queries) || [],
+            environment: collect_environment_info,
+            source_extract: source_extract
+          }
+        end
+
+        def render_error_page_from_info(info, data)
+          # Create a simple exception-like object
+          exception = StandardError.new(info[:message])
+          exception.define_singleton_method(:class) do
+            Class.new(StandardError) do
+              define_singleton_method(:name) { info[:class_name] }
+            end
+          end
+
+          data[:exception] = exception
+          html = @renderer.render(exception, data)
+
+          [
+            500,
+            {
+              'Content-Type' => 'text/html; charset=utf-8',
+              'Content-Length' => html.bytesize.to_s,
+              'X-Content-Type-Options' => 'nosniff'
+            },
+            [html]
+          ]
+        end
+
+        private
+
+        def collect_body(body)
+          full_body = +''
+          body.each { |part| full_body << part }
+          body.close if body.respond_to?(:close)
+          full_body
+        end
+
+        def should_handle?(env)
+          return false unless DevTools.error_page_enabled?
+          return false unless DevTools.allowed_environment?
+          return false unless DevTools.allowed_ip?(extract_ip(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 json_request?(env)
+          accept = env['HTTP_ACCEPT'] || ''
+          content_type = env['CONTENT_TYPE'] || ''
+
+          accept.include?('application/json') ||
+            content_type.include?('application/json') ||
+            env['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest'
+        end
+
+        def capture_to_reflex(exception)
+          return unless defined?(BrainzLab::Reflex)
+
+          BrainzLab::Reflex.capture(exception)
+        rescue StandardError
+          # Ignore errors in error capturing
+        end
+
+        def raise_exception(exception)
+          raise exception
+        end
+
+        def collect_debug_data(env, exception)
+          context = defined?(BrainzLab::Context) ? BrainzLab::Context.current : nil
+          collector_data = Data::Collector.get_request_data
+
+          {
+            exception: exception,
+            backtrace: format_backtrace(exception),
+            request: build_request_info(env, context),
+            context: build_context_info(context),
+            sql_queries: collector_data.dig(:database, :queries) || [],
+            environment: collect_environment_info,
+            source_extract: extract_source_lines(exception)
+          }
+        end
+
+        def build_request_info(env, context)
+          request = defined?(ActionDispatch::Request) ? ActionDispatch::Request.new(env) : nil
+
+          {
+            method: request&.request_method || env['REQUEST_METHOD'],
+            path: request&.path || env['PATH_INFO'],
+            url: request&.url || env['REQUEST_URI'],
+            params: scrub_params(context&.request_params || extract_params(env)),
+            headers: extract_headers(env),
+            session: {}
+          }
+        end
+
+        def build_context_info(context)
+          {
+            controller: context&.controller,
+            action: context&.action,
+            request_id: context&.request_id,
+            user: context&.user
+          }
+        end
+
+        def extract_params(env)
+          return {} unless defined?(Rack::Request)
+
+          Rack::Request.new(env).params
+        rescue StandardError
+          {}
+        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 scrub_params(params)
+          return {} unless params.is_a?(Hash)
+
+          scrub_fields = BrainzLab.configuration.scrub_fields.map(&:to_s)
+
+          params.transform_values.with_index do |(key, value), _|
+            if scrub_fields.include?(key.to_s.downcase)
+              '[FILTERED]'
+            elsif value.is_a?(Hash)
+              scrub_params(value)
+            else
+              value
+            end
+          end
+        rescue StandardError
+          params
+        end
+
+        def format_backtrace(exception)
+          (exception.backtrace || []).first(50).map do |line|
+            parsed = parse_backtrace_line(line)
+            parsed[:in_app] = in_app_frame?(parsed[:file])
+            parsed
+          end
+        end
+
+        def parse_backtrace_line(line)
+          match = line.match(/\A(.+):(\d+)(?::in `(.+)')?/)
+          return { file: line, line: 0, function: nil, raw: line } unless match
+
+          {
+            file: match[1],
+            line: match[2].to_i,
+            function: match[3],
+            raw: line
+          }
+        end
+
+        def in_app_frame?(file)
+          return false unless file
+
+          file.include?('/app/') && !file.include?('/vendor/') && !file.include?('/gems/')
+        end
+
+        def extract_source_from_backtrace(backtrace_lines)
+          return nil if backtrace_lines.empty?
+
+          # Find the first in-app frame
+          target_line = backtrace_lines.find { |line| in_app_frame?(line.split(':').first) }
+          target_line ||= backtrace_lines.first
+
+          match = target_line.match(/\A(.+):(\d+)/)
+          return nil unless match
+
+          file = match[1]
+          line_number = match[2].to_i
+          return nil unless File.exist?(file)
+
+          lines = File.readlines(file)
+          start_line = [line_number - 6, 0].max
+          end_line = [line_number + 4, lines.length - 1].min
+
+          {
+            file: file,
+            line_number: line_number,
+            lines: lines[start_line..end_line].map.with_index do |content, idx|
+              {
+                number: start_line + idx + 1,
+                content: content.chomp,
+                highlight: (start_line + idx + 1) == line_number
+              }
+            end
+          }
+        rescue StandardError
+          nil
+        end
+
+        def extract_source_lines(exception)
+          return nil unless exception.backtrace&.any?
+
+          # Find the first in-app frame (application code, not gems/framework)
+          target_line = exception.backtrace.find { |line| in_app_frame?(line.split(':').first) }
+          # Fall back to first frame if no in-app frame found
+          target_line ||= exception.backtrace.first
+
+          match = target_line.match(/\A(.+):(\d+)/)
+          return nil unless match
+
+          file = match[1]
+          line_number = match[2].to_i
+          return nil unless File.exist?(file)
+
+          lines = File.readlines(file)
+          start_line = [line_number - 6, 0].max
+          end_line = [line_number + 4, lines.length - 1].min
+
+          {
+            file: file,
+            line_number: line_number,
+            lines: lines[start_line..end_line].map.with_index do |content, idx|
+              {
+                number: start_line + idx + 1,
+                content: content.chomp,
+                highlight: (start_line + idx + 1) == line_number
+              }
+            end
+          }
+        rescue StandardError
+          nil
+        end
+
+        def collect_environment_info
+          {
+            rails_version: defined?(::Rails::VERSION::STRING) ? ::Rails::VERSION::STRING : 'N/A',
+            ruby_version: RUBY_VERSION,
+            env: BrainzLab.configuration.environment,
+            server: ENV['SERVER_SOFTWARE'] || 'Unknown',
+            pid: Process.pid
+          }
+        end
+
+        def render_error_page(exception, data)
+          html = @renderer.render(exception, data)
+
+          [
+            500,
+            {
+              'Content-Type' => 'text/html; charset=utf-8',
+              'Content-Length' => html.bytesize.to_s,
+              'X-Content-Type-Options' => 'nosniff'
+            },
+            [html]
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/devtools/renderers/debug_panel_renderer.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'cgi'
+require 'json'
+
+module BrainzLab
+  module DevTools
+    module Renderers
+      class DebugPanelRenderer
+        def initialize
+          @template_path = File.join(DevTools::ASSETS_PATH, 'templates', 'debug_panel.html.erb')
+          # Cache compiled ERB template to avoid file I/O on every request
+          @cached_erb = nil
+          @template_mtime = nil
+        end
+
+        def render(data)
+          erb = cached_erb
+
+          # Make data available to template
+          @data = data
+          @timing = data[:timing] || {}
+          @request = data[:request] || {}
+          @controller = data[:controller] || {}
+          @response = data[:response] || {}
+          @database = data[:database] || {}
+          @views = data[:views] || {}
+          @logs = data[:logs] || []
+          @memory = data[:memory] || {}
+          @user = data[:user]
+          @breadcrumbs = data[:breadcrumbs] || []
+          @expand_by_default = DevTools.expand_by_default?
+          @panel_position = DevTools.panel_position
+
+          erb.result(binding)
+        end
+
+        private
+
+        def h(text)
+          CGI.escapeHTML(text.to_s)
+        end
+
+        def asset_url(file)
+          "#{DevTools.asset_path}/#{file}"
+        end
+
+        def json_pretty(obj)
+          return '' if obj.nil? || (obj.respond_to?(:empty?) && obj.empty?)
+
+          JSON.pretty_generate(obj)
+        rescue StandardError
+          obj.inspect
+        end
+
+        def truncate(text, length = 80)
+          return '' unless text
+
+          text = text.to_s
+          text.length > length ? "#{text[0...length]}..." : text
+        end
+
+        def format_duration(ms)
+          return '0ms' unless ms
+
+          if ms >= 1000
+            "#{(ms / 1000.0).round(2)}s"
+          else
+            "#{ms.round(2)}ms"
+          end
+        end
+
+        def duration_class(ms)
+          return '' unless ms
+
+          if ms > 1000
+            'very-slow'
+          elsif ms > 500
+            'slow'
+          elsif ms > 200
+            'moderate'
+          else
+            ''
+          end
+        end
+
+        def query_duration_class(ms)
+          return '' unless ms
+
+          if ms > 100
+            'very-slow'
+          elsif ms > 50
+            'slow'
+          elsif ms > 10
+            'moderate'
+          else
+            ''
+          end
+        end
+
+        def status_class(status)
+          case status
+          when 200..299 then 'success'
+          when 300..399 then 'redirect'
+          when 400..499 then 'client-error'
+          when 500..599 then 'server-error'
+          else ''
+          end
+        end
+
+        def log_level_class(level)
+          case level.to_s.downcase
+          when 'error', 'fatal' then 'error'
+          when 'warn', 'warning' then 'warning'
+          when 'info' then 'info'
+          when 'debug' then 'debug'
+          else ''
+          end
+        end
+
+        def format_timestamp(time)
+          return '' unless time
+
+          time.strftime('%H:%M:%S.%L')
+        end
+
+        def memory_class(delta_mb)
+          return '' unless delta_mb
+
+          if delta_mb > 50
+            'high'
+          elsif delta_mb > 20
+            'moderate'
+          else
+            ''
+          end
+        end
+
+        # Cache compiled ERB template, reloading only if file changed (dev mode)
+        def cached_erb
+          current_mtime = begin
+            File.mtime(@template_path)
+          rescue StandardError
+            nil
+          end
+
+          if @cached_erb.nil? || (current_mtime && current_mtime != @template_mtime)
+            template = File.read(@template_path)
+            @cached_erb = ERB.new(template, trim_mode: '-')
+            @template_mtime = current_mtime
+          end
+
+          @cached_erb
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/devtools/renderers/error_page_renderer.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'cgi'
+
+module BrainzLab
+  module DevTools
+    module Renderers
+      class ErrorPageRenderer
+        def initialize
+          @template_path = File.join(DevTools::ASSETS_PATH, 'templates', 'error_page.html.erb')
+          @cached_erb = nil
+          @template_mtime = nil
+        end
+
+        def render(exception, data)
+          erb = cached_erb
+
+          # Make data available to template
+          @exception = exception
+          @data = data
+          @backtrace = data[:backtrace] || []
+          @request = data[:request] || {}
+          @context = data[:context] || {}
+          @sql_queries = data[:sql_queries] || []
+          @environment = data[:environment] || {}
+          @source_extract = data[:source_extract]
+
+          erb.result(binding)
+        end
+
+        private
+
+        def h(text)
+          CGI.escapeHTML(text.to_s)
+        end
+
+        def asset_url(file)
+          "#{DevTools.asset_path}/#{file}"
+        end
+
+        def format_params(params, indent = 0)
+          return '' if params.nil? || params.empty?
+
+          lines = []
+          prefix = '  ' * indent
+
+          params.each do |key, value|
+            if value.is_a?(Hash)
+              lines << "#{prefix}#{h(key)}:"
+              lines << format_params(value, indent + 1)
+            elsif value.is_a?(Array)
+              lines << "#{prefix}#{h(key)}: #{h(value.inspect)}"
+            else
+              lines << "#{prefix}#{h(key)}: #{h(value)}"
+            end
+          end
+
+          lines.join("\n")
+        end
+
+        def truncate(text, length = 100)
+          return '' unless text
+
+          text.length > length ? "#{text[0...length]}..." : text
+        end
+
+        def time_ago(time)
+          return 'unknown' unless time
+
+          seconds = Time.now.utc - time
+          case seconds
+          when 0..59 then "#{seconds.to_i}s ago"
+          when 60..3599 then "#{(seconds / 60).to_i}m ago"
+          else "#{(seconds / 3600).to_i}h ago"
+          end
+        end
+
+        # Cache compiled ERB template, reloading only if file changed
+        def cached_erb
+          current_mtime = begin
+            File.mtime(@template_path)
+          rescue StandardError
+            nil
+          end
+
+          if @cached_erb.nil? || (current_mtime && current_mtime != @template_mtime)
+            template = File.read(@template_path)
+            @cached_erb = ERB.new(template, trim_mode: '-')
+            @template_mtime = current_mtime
+          end
+
+          @cached_erb
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/devtools.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative 'devtools/data/collector'
+require_relative 'devtools/middleware/asset_server'
+require_relative 'devtools/middleware/database_handler'
+require_relative 'devtools/middleware/error_page'
+require_relative 'devtools/middleware/debug_panel'
+require_relative 'devtools/renderers/error_page_renderer'
+require_relative 'devtools/renderers/debug_panel_renderer'
+
+module BrainzLab
+  module DevTools
+    ASSETS_PATH = File.expand_path('devtools/assets', __dir__)
+
+    class << self
+      def enabled?
+        BrainzLab.configuration.devtools_enabled
+      end
+
+      def error_page_enabled?
+        enabled? && BrainzLab.configuration.devtools_error_page_enabled
+      end
+
+      def debug_panel_enabled?
+        enabled? && BrainzLab.configuration.devtools_debug_panel_enabled
+      end
+
+      def allowed_environment?
+        allowed = BrainzLab.configuration.devtools_allowed_environments
+        current = BrainzLab.configuration.environment
+        allowed.include?(current)
+      end
+
+      def allowed_ip?(request_ip)
+        # Skip IP checking in development - environment check is enough
+        return true if BrainzLab.configuration.environment == 'development'
+
+        return true if BrainzLab.configuration.devtools_allowed_ips.empty?
+
+        allowed_ips = BrainzLab.configuration.devtools_allowed_ips
+        return true if allowed_ips.include?(request_ip)
+
+        # Check CIDR ranges
+        allowed_ips.any? do |ip|
+          if ip.include?('/')
+            ip_in_cidr?(request_ip, ip)
+          else
+            ip == request_ip
+          end
+        end
+      end
+
+      def asset_path
+        BrainzLab.configuration.devtools_asset_path
+      end
+
+      def panel_position
+        BrainzLab.configuration.devtools_panel_position
+      end
+
+      def expand_by_default?
+        BrainzLab.configuration.devtools_expand_by_default
+      end
+
+      private
+
+      def ip_in_cidr?(ip, cidr)
+        require 'ipaddr'
+        IPAddr.new(cidr).include?(IPAddr.new(ip))
+      rescue IPAddr::InvalidAddressError
+        false
+      end
+    end
+  end
+end