brainzlab 0.1.1 → 0.1.3

data/lib/brainzlab/rails/log_subscriber.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_support/log_subscriber"
+require 'active_support/log_subscriber'
 
 module BrainzLab
   module Rails
@@ -21,12 +21,11 @@ module BrainzLab
         params = payload[:params]&.except(*INTERNAL_PARAMS) || {}
 
         formatter.start_request(request_id,
-          method: payload[:method],
-          path: payload[:path],
-          params: filter_params(params),
-          controller: payload[:controller],
-          action: payload[:action]
-        )
+                                method: payload[:method],
+                                path: payload[:path],
+                                params: filter_params(params),
+                                controller: payload[:controller],
+                                action: payload[:action])
       end
 
       def process_action(event)
@@ -38,18 +37,15 @@ module BrainzLab
         payload = event.payload
 
         formatter.process_action(request_id,
-          controller: payload[:controller],
-          action: payload[:action],
-          status: payload[:status],
-          duration: event.duration,
-          view_runtime: payload[:view_runtime],
-          db_runtime: payload[:db_runtime]
-        )
+                                 controller: payload[:controller],
+                                 action: payload[:action],
+                                 status: payload[:status],
+                                 duration: event.duration,
+                                 view_runtime: payload[:view_runtime],
+                                 db_runtime: payload[:db_runtime])
 
         # Handle exception if present
-        if payload[:exception_object]
-          formatter.error(request_id, payload[:exception_object])
-        end
+        formatter.error(request_id, payload[:exception_object]) if payload[:exception_object]
 
         # Output the formatted log
         output = formatter.end_request(request_id)
@@ -81,11 +77,11 @@ module BrainzLab
         case obj
         when Hash
           obj.each_with_object({}) do |(k, v), h|
-            if filter_keys.include?(k.to_s.downcase)
-              h[k] = "[FILTERED]"
-            else
-              h[k] = deep_filter(v, filter_keys)
-            end
+            h[k] = if filter_keys.include?(k.to_s.downcase)
+                     '[FILTERED]'
+                   else
+                     deep_filter(v, filter_keys)
+                   end
           end
         when Array
           obj.map { |v| deep_filter(v, filter_keys) }
@@ -121,13 +117,12 @@ module BrainzLab
         sql_pattern = normalize_sql(payload[:sql])
 
         LogSubscriber.formatter.sql_query(request_id,
-          name: payload[:name],
-          duration: event.duration,
-          sql: payload[:sql],
-          sql_pattern: sql_pattern,
-          cached: payload[:cached] || payload[:name] == "CACHE",
-          source: source
-        )
+                                          name: payload[:name],
+                                          duration: event.duration,
+                                          sql: payload[:sql],
+                                          sql_pattern: sql_pattern,
+                                          cached: payload[:cached] || payload[:name] == 'CACHE',
+                                          source: source)
       end
 
       private
@@ -135,11 +130,11 @@ module BrainzLab
       def extract_source_location(backtrace)
         # Find the first line that's in app/ directory
         backtrace.each do |line|
-          if line.include?("/app/") && !line.include?("/brainzlab")
-            # Extract just the relevant part: app/models/user.rb:42
-            match = line.match(%r{(app/[^:]+:\d+)})
-            return match[1] if match
-          end
+          next unless line.include?('/app/') && !line.include?('/brainzlab')
+
+          # Extract just the relevant part: app/models/user.rb:42
+          match = line.match(%r{(app/[^:]+:\d+)})
+          return match[1] if match
         end
         nil
       end
@@ -148,12 +143,11 @@ module BrainzLab
         return nil unless sql
 
         sql
-          .gsub(/\b\d+\b/, "?")                    # Replace numbers
-          .gsub(/'[^']*'/, "?")                    # Replace strings
-          .gsub(/"[^"]*"/, "?")                    # Replace double-quoted strings
-          .gsub(/\$\d+/, "?")                      # Replace positional params
-          .gsub(/\/\*.*?\*\//, "")                 # Remove comments
-          .gsub(/\s+/, " ")                        # Normalize whitespace
+          .gsub(/\b\d+\b/, '?')                    # Replace numbers
+          .gsub(/'[^']*'/, '?')                    # Replace single-quoted strings
+          .gsub(/\$\d+/, '?')                      # Replace positional params
+          .gsub(%r{/\*.*?\*/}, '')                 # Remove comments
+          .gsub(/\s+/, ' ')                        # Normalize whitespace
           .strip
       end
     end
@@ -183,18 +177,18 @@ module BrainzLab
         return broadcasting unless broadcasting
 
         # Extract channel name from gid format: logs:Z2lkOi8vcmVjYWxsL1Byb2plY3QvNDhi...
-        if broadcasting.start_with?("logs:")
-          "LogsChannel"
-        elsif broadcasting.include?(":")
+        if broadcasting.start_with?('logs:')
+          'LogsChannel'
+        elsif broadcasting.include?(':')
           # Generic channel:id format
-          broadcasting.split(":").first.capitalize + "Channel"
+          "#{broadcasting.split(':').first.capitalize}Channel"
         else
           broadcasting
         end
       end
 
       def format_message(message)
-        return "{}" unless message
+        return '{}' unless message
 
         case message
         when Hash
@@ -215,58 +209,60 @@ module BrainzLab
         parts = []
 
         # Show key fields for log entries
-        if hash["level"] || hash[:level]
-          level = hash["level"] || hash[:level]
+        if hash['level'] || hash[:level]
+          level = hash['level'] || hash[:level]
           parts << colorize_level(level)
         end
 
-        if hash["message"] || hash[:message]
-          msg = hash["message"] || hash[:message]
+        if hash['message'] || hash[:message]
+          msg = hash['message'] || hash[:message]
           parts << truncate(msg.to_s, 50)
         end
 
-        if hash["id"] || hash[:id]
-          id = hash["id"] || hash[:id]
+        if hash['id'] || hash[:id]
+          id = hash['id'] || hash[:id]
           parts << colorize(id.to_s[0..7], :gray)
         end
 
-        parts.any? ? parts.join(" ") : hash.keys.first(3).join(", ")
+        parts.any? ? parts.join(' ') : hash.keys.first(3).join(', ')
       end
 
       def build_output(channel, message, duration)
-        time = Time.current.strftime("%H:%M:%S")
-        duration_str = duration ? "#{duration.round(1)}ms" : ""
+        time = Time.current.strftime('%H:%M:%S')
+        duration_str = duration ? "#{duration.round(1)}ms" : ''
 
         parts = [
           colorize(time, :gray),
-          colorize("⚡", :magenta),
+          colorize('⚡', :magenta),
           colorize(channel, :magenta),
-          colorize("→", :gray),
+          colorize('→', :gray),
           message,
           colorize(duration_str, :gray)
         ]
 
-        "  " + parts.join("  ") + "\n"
+        "  #{parts.join('  ')}\n"
       end
 
       def truncate(text, length)
         return text if text.nil? || text.length <= length
+
         "#{text[0..(length - 4)]}..."
       end
 
       def colorize(text, color)
         return text unless $stdout.tty?
         return text unless COLORS[color]
+
         "#{COLORS[color]}#{text}#{COLORS[:reset]}"
       end
 
       def colorize_level(level)
         color = case level.to_s.downcase
-                when "debug" then :gray
-                when "info" then :green
-                when "warn", "warning" then :yellow
-                when "error" then :red
-                when "fatal" then :red
+                when 'debug' then :gray
+                when 'info' then :green
+                when 'warn', 'warning' then :yellow
+                when 'error' then :red
+                when 'fatal' then :red
                 else :white
                 end
         colorize(level.to_s.upcase.ljust(5), color)
@@ -285,10 +281,9 @@ module BrainzLab
         template = template_name(payload[:identifier])
 
         LogSubscriber.formatter.render_template(request_id,
-          template: template,
-          duration: event.duration,
-          layout: payload[:layout]
-        )
+                                                template: template,
+                                                duration: event.duration,
+                                                layout: payload[:layout])
       end
 
       def render_partial(event)
@@ -301,10 +296,9 @@ module BrainzLab
         template = template_name(payload[:identifier])
 
         LogSubscriber.formatter.render_partial(request_id,
-          template: template,
-          duration: event.duration,
-          count: payload[:count]
-        )
+                                               template: template,
+                                               duration: event.duration,
+                                               count: payload[:count])
       end
 
       def render_layout(event)
@@ -317,9 +311,8 @@ module BrainzLab
         layout = template_name(payload[:identifier])
 
         LogSubscriber.formatter.render_layout(request_id,
-          layout: layout,
-          duration: event.duration
-        )
+                                              layout: layout,
+                                              duration: event.duration)
       end
 
       private
@@ -328,10 +321,10 @@ module BrainzLab
         return nil unless identifier
 
         # Extract relative path from full identifier
-        if identifier.include?("/app/views/")
-          identifier.split("/app/views/").last
-        elsif identifier.include?("/views/")
-          identifier.split("/views/").last
+        if identifier.include?('/app/views/')
+          identifier.split('/app/views/').last
+        elsif identifier.include?('/views/')
+          identifier.split('/views/').last
         else
           File.basename(identifier)
         end

data/lib/brainzlab/rails/railtie.rb

@@ -1,13 +1,25 @@
 # frozen_string_literal: true
 
+require 'English'
 module BrainzLab
   module Rails
     class Railtie < ::Rails::Railtie
       generators do
-        require "generators/brainzlab/install/install_generator"
+        require 'generators/brainzlab/install/install_generator'
       end
 
-      initializer "brainzlab.configure_rails_initialization" do |app|
+      # Load Vault secrets early, before configuration
+      # This allows secrets to be used in config files
+      initializer 'brainzlab.load_vault_secrets', before: :load_environment_config do
+        if BrainzLab.configuration.vault_enabled && BrainzLab.configuration.vault_auto_load
+          BrainzLab.debug_log('[Vault] Auto-loading secrets into ENV...')
+          BrainzLab::Vault.load!(
+            provider_keys: BrainzLab.configuration.vault_load_provider_keys
+          )
+        end
+      end
+
+      initializer 'brainzlab.configure_rails_initialization' do |app|
         # Set defaults from Rails
         BrainzLab.configure do |config|
           config.environment ||= ::Rails.env.to_s
@@ -20,11 +32,31 @@ module BrainzLab
 
         # Add request context middleware (runs early)
         app.middleware.insert_after ActionDispatch::RequestId, BrainzLab::Rails::Middleware
+
+        # Add DevTools middlewares if enabled
+        if BrainzLab.configuration.devtools_enabled
+          require_relative '../devtools'
+
+          # Asset server (handles /__brainzlab__/* requests)
+          app.middleware.insert_before ActionDispatch::Static, BrainzLab::DevTools::Middleware::AssetServer
+
+          # Database handler (handles /_brainzlab/devtools/database POST requests)
+          # Allows running migrations from the error page
+          app.middleware.insert_before ActionDispatch::Static, BrainzLab::DevTools::Middleware::DatabaseHandler
+
+          # Error page (catches exceptions and renders branded error page)
+          # Insert BEFORE DebugExceptions so we can intercept the HTML error page
+          # that DebugExceptions renders and replace it with our own
+          app.middleware.insert_before ActionDispatch::DebugExceptions, BrainzLab::DevTools::Middleware::ErrorPage if defined?(ActionDispatch::DebugExceptions)
+
+          # Debug panel (injects panel into HTML responses)
+          app.middleware.use BrainzLab::DevTools::Middleware::DebugPanel
+        end
       end
 
       config.after_initialize do
         # Set up custom log formatter
-        setup_log_formatter if BrainzLab.configuration.log_formatter_enabled
+        BrainzLab::Rails::Railtie.setup_log_formatter if BrainzLab.configuration.log_formatter_enabled
 
         # Install instrumentation (HTTP tracking, etc.)
         BrainzLab::Instrumentation.install!
@@ -38,14 +70,10 @@ module BrainzLab
         end
 
         # Hook into ActiveJob
-        if defined?(ActiveJob::Base)
-          ActiveJob::Base.include(BrainzLab::Rails::ActiveJobExtension)
-        end
+        ActiveJob::Base.include(BrainzLab::Rails::ActiveJobExtension) if defined?(ActiveJob::Base)
 
         # Hook into ActionController for rescue_from fallback
-        if defined?(ActionController::Base)
-          ActionController::Base.include(BrainzLab::Rails::ControllerExtension)
-        end
+        ActionController::Base.include(BrainzLab::Rails::ControllerExtension) if defined?(ActionController::Base)
 
         # Hook into Sidekiq if available
         if defined?(Sidekiq)
@@ -58,8 +86,8 @@ module BrainzLab
       class << self
         def setup_log_formatter
           # Lazy require to ensure Rails is fully loaded
-          require_relative "log_formatter"
-          require_relative "log_subscriber"
+          require_relative 'log_formatter'
+          require_relative 'log_subscriber'
 
           config = BrainzLab.configuration
 
@@ -91,37 +119,23 @@ module BrainzLab
           null_logger.level = Logger::FATAL
 
           # Silence ActiveRecord SQL logging
-          if defined?(ActiveRecord::Base)
-            ActiveRecord::Base.logger = null_logger
-          end
+          ActiveRecord::Base.logger = null_logger if defined?(ActiveRecord::Base)
 
           # Silence ActionController logging (the "Completed" message)
-          if defined?(ActionController::Base)
-            ActionController::Base.logger = null_logger
-          end
+          ActionController::Base.logger = null_logger if defined?(ActionController::Base)
 
           # Silence ActionView logging
-          if defined?(ActionView::Base)
-            ActionView::Base.logger = null_logger
-          end
+          ActionView::Base.logger = null_logger if defined?(ActionView::Base)
 
           # Silence the class-level loggers for specific subscribers
-          if defined?(ActionController::LogSubscriber)
-            ActionController::LogSubscriber.logger = null_logger
-          end
+          ActionController::LogSubscriber.logger = null_logger if defined?(ActionController::LogSubscriber)
 
-          if defined?(ActionView::LogSubscriber)
-            ActionView::LogSubscriber.logger = null_logger
-          end
+          ActionView::LogSubscriber.logger = null_logger if defined?(ActionView::LogSubscriber)
 
-          if defined?(ActiveRecord::LogSubscriber)
-            ActiveRecord::LogSubscriber.logger = null_logger
-          end
+          ActiveRecord::LogSubscriber.logger = null_logger if defined?(ActiveRecord::LogSubscriber)
 
           # Silence ActionCable logging
-          if defined?(ActionCable::Server::Base)
-            ActionCable.server.config.logger = null_logger
-          end
+          ActionCable.server.config.logger = null_logger if defined?(ActionCable::Server::Base)
 
           if defined?(ActionCable::Connection::TaggedLoggerProxy)
             # ActionCable uses a tagged logger proxy that we need to quiet
@@ -151,7 +165,7 @@ module BrainzLab
         /^Rendering/,
         /^Rendered/,
         /^\[ActionCable\] Broadcasting/,
-        /^\s*$/  # Empty lines
+        /^\s*$/ # Empty lines
       ].freeze
 
       def call(severity, datetime, progname, msg)
@@ -182,7 +196,7 @@ module BrainzLab
 
         # Set request context
         context = BrainzLab::Context.current
-        request_id = request.request_id || env["action_dispatch.request_id"]
+        request_id = request.request_id || env['action_dispatch.request_id']
         context.request_id = request_id
 
         # Store request_id in thread local for log subscriber
@@ -191,7 +205,11 @@ module BrainzLab
         # Capture session_id - access session to ensure it's loaded
         if request.session.respond_to?(:id)
           # Force session load by accessing it
-          session_id = request.session.id rescue nil
+          session_id = begin
+            request.session.id
+          rescue StandardError
+            nil
+          end
           context.session_id = session_id.to_s if session_id.present?
         end
 
@@ -205,7 +223,7 @@ module BrainzLab
         # Add breadcrumb for request start
         BrainzLab::Reflex.add_breadcrumb(
           "#{request.request_method} #{request.path}",
-          category: "http.request",
+          category: 'http.request',
           level: :info,
           data: { url: request.url }
         )
@@ -229,7 +247,7 @@ module BrainzLab
           Thread.current[:brainzlab_pulse_breakdown] = nil
           BrainzLab::Pulse.start_trace(
             "#{request.request_method} #{request.path}",
-            kind: "request",
+            kind: 'request',
             parent_context: parent_context
           )
         end
@@ -239,7 +257,7 @@ module BrainzLab
         # Add breadcrumb for response
         BrainzLab::Reflex.add_breadcrumb(
           "Response #{status}",
-          category: "http.response",
+          category: 'http.response',
           level: status >= 400 ? :error : :info,
           data: { status: status }
         )
@@ -257,9 +275,7 @@ module BrainzLab
         raise
       ensure
         # Finish Pulse trace for successful requests
-        if should_trace && !$!
-          record_pulse_trace(request, started_at, status)
-        end
+        record_pulse_trace(request, started_at, status) if should_trace && !$ERROR_INFO
 
         Thread.current[:brainzlab_request_id] = nil
         BrainzLab::Context.clear!
@@ -273,8 +289,8 @@ module BrainzLab
         path = request.path
 
         # Check if path matches any excluded pattern
-        !excluded.any? do |pattern|
-          if pattern.include?("*")
+        excluded.none? do |pattern|
+          if pattern.include?('*')
             File.fnmatch?(pattern, path)
           else
             path.start_with?(pattern)
@@ -290,7 +306,6 @@ module BrainzLab
         spans = Thread.current[:brainzlab_pulse_spans] || []
         breakdown = Thread.current[:brainzlab_pulse_breakdown] || {}
 
-
         # Format spans for API
         formatted_spans = spans.map do |span|
           {
@@ -306,7 +321,7 @@ module BrainzLab
 
         BrainzLab::Pulse.record_trace(
           "#{request.request_method} #{request.path}",
-          kind: "request",
+          kind: 'request',
           started_at: started_at,
           ended_at: ended_at,
           request_id: context.request_id,
@@ -344,11 +359,11 @@ module BrainzLab
         case obj
         when Hash
           obj.each_with_object({}) do |(k, v), h|
-            if BrainzLab::Reflex::FILTERED_PARAMS.include?(k.to_s)
-              h[k] = "[FILTERED]"
-            else
-              h[k] = deep_filter(v)
-            end
+            h[k] = if BrainzLab::Reflex::FILTERED_PARAMS.include?(k.to_s)
+                     '[FILTERED]'
+                   else
+                     deep_filter(v)
+                   end
           end
         when Array
           obj.map { |v| deep_filter(v) }
@@ -375,11 +390,11 @@ module BrainzLab
       def extract_headers(env)
         headers = {}
         env.each do |key, value|
-          next unless key.start_with?("HTTP_")
-          next if key == "HTTP_COOKIE"
-          next if key == "HTTP_AUTHORIZATION"
+          next unless key.start_with?('HTTP_')
+          next if key == 'HTTP_COOKIE'
+          next if key == 'HTTP_AUTHORIZATION'
 
-          header_name = key.sub("HTTP_", "").split("_").map(&:capitalize).join("-")
+          header_name = key.sub('HTTP_', '').split('_').map(&:capitalize).join('-')
           headers[header_name] = value
         end
         headers
@@ -391,11 +406,10 @@ module BrainzLab
       def report(error, handled:, severity:, context: {}, source: nil)
         # Capture both handled and unhandled, but mark them
         BrainzLab::Reflex.capture(error,
-          handled: handled,
-          severity: severity.to_s,
-          source: source,
-          extra: context
-        )
+                                  handled: handled,
+                                  severity: severity.to_s,
+                                  source: source,
+                                  extra: context)
       rescue StandardError => e
         BrainzLab.configuration.logger&.error("[BrainzLab] ErrorSubscriber failed: #{e.message}")
       end
@@ -421,7 +435,7 @@ module BrainzLab
         # Add breadcrumb
         BrainzLab::Reflex.add_breadcrumb(
           "#{self.class.name}##{action_name}",
-          category: "controller",
+          category: 'controller',
           level: :info
         )
 
@@ -458,7 +472,7 @@ module BrainzLab
 
         BrainzLab::Reflex.add_breadcrumb(
           "Job #{self.class.name}",
-          category: "job",
+          category: 'job',
           level: :info,
           data: { job_id: job_id, queue: queue_name }
         )
@@ -468,7 +482,7 @@ module BrainzLab
         if should_trace
           Thread.current[:brainzlab_pulse_spans] = []
           Thread.current[:brainzlab_pulse_breakdown] = nil
-          BrainzLab::Pulse.start_trace(self.class.name, kind: "job")
+          BrainzLab::Pulse.start_trace(self.class.name, kind: 'job')
         end
 
         error_occurred = nil
@@ -480,9 +494,7 @@ module BrainzLab
         end
       ensure
         # Record Pulse trace for job
-        if should_trace
-          record_pulse_job_trace(started_at, error_occurred)
-        end
+        record_pulse_job_trace(started_at, error_occurred) if should_trace
 
         BrainzLab::Context.clear!
       end
@@ -517,7 +529,7 @@ module BrainzLab
 
         BrainzLab::Pulse.record_trace(
           self.class.name,
-          kind: "job",
+          kind: 'job',
           started_at: started_at,
           ended_at: ended_at,
           job_class: self.class.name,
@@ -556,32 +568,30 @@ module BrainzLab
 
       def brainzlab_rescue_job(exception)
         BrainzLab::Reflex.capture(exception,
-          tags: { type: "background_job" },
-          extra: {
-            job_class: self.class.name,
-            job_id: job_id,
-            queue_name: queue_name,
-            executions: executions,
-            arguments: arguments.map(&:to_s).first(5)
-          }
-        )
+                                  tags: { type: 'background_job' },
+                                  extra: {
+                                    job_class: self.class.name,
+                                    job_id: job_id,
+                                    queue_name: queue_name,
+                                    executions: executions,
+                                    arguments: arguments.map(&:to_s).first(5)
+                                  })
         raise exception # Re-raise to let ActiveJob handle retries
       end
     end
 
-    # Sidekiq error handler
+    # Sidekiq error handler - Sidekiq 7.x+ requires 3 arguments
     class SidekiqErrorHandler
-      def call(exception, context)
+      def call(exception, context, _config = nil)
         BrainzLab::Reflex.capture(exception,
-          tags: { type: "sidekiq" },
-          extra: {
-            job_class: context[:job]["class"],
-            job_id: context[:job]["jid"],
-            queue: context[:job]["queue"],
-            args: context[:job]["args"]&.map(&:to_s)&.first(5),
-            retry_count: context[:job]["retry_count"]
-          }
-        )
+                                  tags: { type: 'sidekiq' },
+                                  extra: {
+                                    job_class: context[:job]['class'],
+                                    job_id: context[:job]['jid'],
+                                    queue: context[:job]['queue'],
+                                    args: context[:job]['args']&.map(&:to_s)&.first(5),
+                                    retry_count: context[:job]['retry_count']
+                                  })
       rescue StandardError => e
         BrainzLab.configuration.logger&.error("[BrainzLab] Sidekiq handler failed: #{e.message}")
       end

data/lib/brainzlab/recall/buffer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "concurrent"
+require 'concurrent'
 
 module BrainzLab
   module Recall