brainzlab 0.1.1 → 0.1.2

data/lib/brainzlab/nerve.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative "nerve/client"
+require_relative "nerve/provisioner"
+
+module BrainzLab
+  module Nerve
+    class << self
+      # Report a completed job
+      # @param job_class [String] Job class name
+      # @param job_id [String] Job ID
+      # @param queue [String] Queue name
+      # @param started_at [Time] When job started
+      # @param ended_at [Time] When job ended (defaults to now)
+      # @param attributes [Hash] Additional attributes
+      #
+      # @example
+      #   BrainzLab::Nerve.report_success(
+      #     job_class: "ProcessOrderJob",
+      #     job_id: "abc-123",
+      #     queue: "default",
+      #     started_at: 1.minute.ago
+      #   )
+      #
+      def report_success(job_class:, job_id:, queue:, started_at:, ended_at: Time.now, **attributes)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.nerve_valid?
+
+        client.report_job(
+          job_class: job_class,
+          job_id: job_id,
+          queue: queue,
+          status: "completed",
+          started_at: started_at,
+          ended_at: ended_at,
+          **attributes
+        )
+      end
+
+      # Report a failed job
+      def report_failure(job_class:, job_id:, queue:, error:, started_at: nil, **attributes)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.nerve_valid?
+
+        client.report_failure(
+          job_class: job_class,
+          job_id: job_id,
+          queue: queue,
+          error_class: error.class.name,
+          error_message: error.message,
+          backtrace: error.backtrace,
+          started_at: started_at,
+          **attributes
+        )
+      end
+
+      # Report a job that's currently running
+      def report_started(job_class:, job_id:, queue:, **attributes)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.nerve_valid?
+
+        client.report_job(
+          job_class: job_class,
+          job_id: job_id,
+          queue: queue,
+          status: "running",
+          started_at: Time.now,
+          ended_at: Time.now,
+          **attributes
+        )
+      end
+
+      # Get job statistics
+      # @param queue [String] Filter by queue (optional)
+      # @param job_class [String] Filter by job class (optional)
+      # @param period [String] Time period: "1h", "24h", "7d", "30d"
+      def stats(queue: nil, job_class: nil, period: "1h")
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.nerve_valid?
+
+        client.stats(queue: queue, job_class: job_class, period: period)
+      end
+
+      # List recent jobs
+      def jobs(queue: nil, status: nil, limit: 100)
+        return [] unless enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.nerve_valid?
+
+        client.list_jobs(queue: queue, status: status, limit: limit)
+      end
+
+      # List all queues
+      def queues
+        return [] unless enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.nerve_valid?
+
+        client.list_queues
+      end
+
+      # Get queue details
+      def queue(name)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.nerve_valid?
+
+        client.get_queue(name)
+      end
+
+      # Retry a failed job
+      def retry(job_id)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.nerve_valid?
+
+        client.retry_job(job_id)
+      end
+
+      # Delete a job
+      def delete(job_id)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.nerve_valid?
+
+        client.delete_job(job_id)
+      end
+
+      # Report queue metrics (for custom job backends)
+      def report_metrics(queue:, size:, latency_ms: nil, workers: nil)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.nerve_valid?
+
+        client.report_metrics(
+          queue: queue,
+          size: size,
+          latency_ms: latency_ms,
+          workers: workers
+        )
+      end
+
+      # Track a job execution (block helper)
+      # @example
+      #   BrainzLab::Nerve.track(job_class: "MyJob", job_id: "123", queue: "default") do
+      #     # job work
+      #   end
+      #
+      def track(job_class:, job_id:, queue: "default", **attributes)
+        started_at = Time.now
+
+        begin
+          result = yield
+          report_success(
+            job_class: job_class,
+            job_id: job_id,
+            queue: queue,
+            started_at: started_at,
+            **attributes
+          )
+          result
+        rescue StandardError => e
+          report_failure(
+            job_class: job_class,
+            job_id: job_id,
+            queue: queue,
+            error: e,
+            started_at: started_at,
+            **attributes
+          )
+          raise
+        end
+      end
+
+      # === INTERNAL ===
+
+      def ensure_provisioned!
+        return if @provisioned
+
+        @provisioned = true
+        provisioner.ensure_project!
+      end
+
+      def provisioner
+        @provisioner ||= Provisioner.new(BrainzLab.configuration)
+      end
+
+      def client
+        @client ||= Client.new(BrainzLab.configuration)
+      end
+
+      def reset!
+        @client = nil
+        @provisioner = nil
+        @provisioned = false
+      end
+
+      private
+
+      def enabled?
+        BrainzLab.configuration.nerve_enabled
+      end
+    end
+  end
+end

data/lib/brainzlab/pulse/instrumentation.rb

@@ -26,6 +26,7 @@ module BrainzLab
             event = ActiveSupport::Notifications::Event.new(*args)
             next if skip_query?(event.payload)
 
+            sql = event.payload[:sql]
             record_span(
               name: event.payload[:name] || "SQL",
               kind: "db",
@@ -33,9 +34,11 @@ module BrainzLab
               ended_at: event.end,
               duration_ms: event.duration,
               data: {
-                sql: truncate_sql(event.payload[:sql]),
+                sql: truncate_sql(sql),
                 name: event.payload[:name],
-                cached: event.payload[:cached] || false
+                cached: event.payload[:cached] || false,
+                table: extract_table(sql),
+                operation: extract_operation(sql)
               }
             )
           end
@@ -358,6 +361,36 @@ module BrainzLab
           return nil unless path
           path.to_s.split("/").last(2).join("/")
         end
+
+        def extract_table(sql)
+          return nil unless sql
+
+          # Match FROM "table" or FROM table patterns
+          # Also handles INSERT INTO, UPDATE, DELETE FROM
+          case sql.to_s
+          when /\bFROM\s+["'`]?(\w+)["'`]?/i
+            Regexp.last_match(1)
+          when /\bINTO\s+["'`]?(\w+)["'`]?/i
+            Regexp.last_match(1)
+          when /\bUPDATE\s+["'`]?(\w+)["'`]?/i
+            Regexp.last_match(1)
+          when /\bJOIN\s+["'`]?(\w+)["'`]?/i
+            Regexp.last_match(1)
+          end
+        end
+
+        def extract_operation(sql)
+          return nil unless sql
+
+          case sql.to_s.strip.upcase
+          when /\ASELECT/i then "SELECT"
+          when /\AINSERT/i then "INSERT"
+          when /\AUPDATE/i then "UPDATE"
+          when /\ADELETE/i then "DELETE"
+          when /\ABEGIN/i, /\ACOMMIT/i, /\AROLLBACK/i then "TRANSACTION"
+          else "QUERY"
+          end
+        end
       end
     end
   end

data/lib/brainzlab/pulse/propagation.rb

@@ -31,7 +31,7 @@ module BrainzLab
         end
 
         def valid?
-          @trace_id && @span_id
+          !trace_id.nil? && !span_id.nil?
         end
 
         def to_h

data/lib/brainzlab/pulse/tracer.rb

@@ -52,7 +52,7 @@ module BrainzLab
         ).compact
 
         # Add request context if available
-        ctx = Context.current
+        ctx = BrainzLab::Context.current
         payload[:request_id] ||= ctx.request_id
         payload[:user_id] ||= ctx.user&.dig(:id)&.to_s
 

data/lib/brainzlab/pulse.rb

@@ -160,7 +160,7 @@ module BrainzLab
       end
 
       def enabled?
-        BrainzLab.configuration.pulse_enabled
+        BrainzLab.configuration.pulse_effectively_enabled?
       end
 
       def build_trace_payload(name, kind, started_at, ended_at, attributes)

data/lib/brainzlab/rails/log_subscriber.rb

@@ -149,8 +149,7 @@ module BrainzLab
 
         sql
           .gsub(/\b\d+\b/, "?")                    # Replace numbers
-          .gsub(/'[^']*'/, "?")                    # Replace strings
-          .gsub(/"[^"]*"/, "?")                    # Replace double-quoted strings
+          .gsub(/'[^']*'/, "?")                    # Replace single-quoted strings
           .gsub(/\$\d+/, "?")                      # Replace positional params
           .gsub(/\/\*.*?\*\//, "")                 # Remove comments
           .gsub(/\s+/, " ")                        # Normalize whitespace

data/lib/brainzlab/rails/railtie.rb

@@ -7,6 +7,17 @@ module BrainzLab
         require "generators/brainzlab/install/install_generator"
       end
 
+      # 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|
@@ -20,11 +31,33 @@ 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
+          if defined?(ActionDispatch::DebugExceptions)
+            app.middleware.insert_before ActionDispatch::DebugExceptions, BrainzLab::DevTools::Middleware::ErrorPage
+          end
+
+          # 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!
@@ -569,9 +602,9 @@ module BrainzLab
       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: {

data/lib/brainzlab/recall/provisioner.rb

@@ -37,14 +37,31 @@ module BrainzLab
       private
 
       def should_provision?
+        if @config.debug
+          log_debug("Checking provision conditions:")
+          log_debug("  recall_auto_provision: #{@config.recall_auto_provision}")
+          log_debug("  app_name: '#{@config.app_name}'")
+          log_debug("  secret_key set: #{@config.secret_key.to_s.strip.length > 0}")
+          log_debug("  recall_master_key set: #{@config.recall_master_key.to_s.strip.length > 0}")
+        end
+
         return false unless @config.recall_auto_provision
         return false unless @config.app_name.to_s.strip.length > 0
         return false if @config.secret_key.to_s.strip.length > 0
         return false unless @config.recall_master_key.to_s.strip.length > 0
 
+        log_debug("Will provision Recall project") if @config.debug
         true
       end
 
+      def log_debug(message)
+        if @config.logger
+          @config.logger.info("[BrainzLab::Debug] #{message}")
+        else
+          puts "[BrainzLab::Debug] #{message}"
+        end
+      end
+
       def provision_project
         uri = URI.parse("#{@config.recall_url}/api/v1/projects/provision")
         request = Net::HTTP::Post.new(uri)

data/lib/brainzlab/recall.rb

@@ -30,7 +30,7 @@ module BrainzLab
 
       def log(level, message, **data)
         config = BrainzLab.configuration
-        return unless config.recall_enabled
+        return unless config.recall_effectively_enabled?
 
         # Auto-provision project on first log if app_name is configured
         ensure_provisioned!
@@ -43,6 +43,11 @@ module BrainzLab
       end
 
       def ensure_provisioned!
+        config = BrainzLab.configuration
+        if config.debug
+          puts "[BrainzLab::Debug] Recall.ensure_provisioned! called, @provisioned=#{@provisioned}"
+        end
+
         return if @provisioned
 
         @provisioned = true

data/lib/brainzlab/reflex.rb

@@ -77,7 +77,7 @@ module BrainzLab
       private
 
       def enabled?
-        BrainzLab.configuration.reflex_enabled
+        BrainzLab.configuration.reflex_effectively_enabled?
       end
 
       def capture_disabled?
@@ -245,7 +245,7 @@ module BrainzLab
         # - "path/to/file.rb:42:in `method_name'"  (backtick + single quote)
         # - "path/to/file.rb:42:in 'method_name'"  (single quotes)
         # - "path/to/file.rb:42"                   (no method)
-        if line =~ /\A(.+):(\d+):in [`'](.+)'?\z/
+        if line =~ /\A(.+):(\d+):in [`']([^']+)'?\z/
           {
             file: $1,
             line: $2.to_i,

data/lib/brainzlab/sentinel/client.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module BrainzLab
+  module Sentinel
+    class Client
+      def initialize(config)
+        @config = config
+        @base_url = config.sentinel_url || "https://sentinel.brainzlab.ai"
+      end
+
+      # List all registered hosts
+      def list_hosts(status: nil, page: 1, per_page: 50)
+        params = { page: page, per_page: per_page }
+        params[:status] = status if status
+
+        response = request(:get, "/api/v1/hosts", params: params)
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:hosts] || []
+      rescue StandardError => e
+        log_error("list_hosts", e)
+        []
+      end
+
+      # Get host details
+      def get_host(host_id)
+        response = request(:get, "/api/v1/hosts/#{host_id}")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_host", e)
+        nil
+      end
+
+      # Get host metrics
+      # @param host_id [String] Host ID
+      # @param period [String] Time period (1h, 6h, 24h, 7d, 30d)
+      # @param metrics [Array<String>] Specific metrics to fetch (cpu, memory, disk, network)
+      def get_metrics(host_id, period: "1h", metrics: nil)
+        params = { period: period }
+        params[:metrics] = metrics.join(",") if metrics
+
+        response = request(:get, "/api/v1/hosts/#{host_id}/metrics", params: params)
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_metrics", e)
+        nil
+      end
+
+      # Get top processes for a host
+      def get_processes(host_id, sort_by: "cpu", limit: 20)
+        params = { sort_by: sort_by, limit: limit }
+
+        response = request(:get, "/api/v1/hosts/#{host_id}/processes", params: params)
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:processes] || []
+      rescue StandardError => e
+        log_error("get_processes", e)
+        []
+      end
+
+      # List all containers
+      def list_containers(host_id: nil, status: nil)
+        params = {}
+        params[:host_id] = host_id if host_id
+        params[:status] = status if status
+
+        response = request(:get, "/api/v1/containers", params: params)
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:containers] || []
+      rescue StandardError => e
+        log_error("list_containers", e)
+        []
+      end
+
+      # Get container details
+      def get_container(container_id)
+        response = request(:get, "/api/v1/containers/#{container_id}")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_container", e)
+        nil
+      end
+
+      # Get container metrics
+      def get_container_metrics(container_id, period: "1h")
+        params = { period: period }
+
+        response = request(:get, "/api/v1/containers/#{container_id}/metrics", params: params)
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_container_metrics", e)
+        nil
+      end
+
+      # Get alerts for a host
+      def get_alerts(host_id: nil, status: nil, severity: nil)
+        params = {}
+        params[:host_id] = host_id if host_id
+        params[:status] = status if status
+        params[:severity] = severity if severity
+
+        response = request(:get, "/api/v1/alerts", params: params)
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:alerts] || []
+      rescue StandardError => e
+        log_error("get_alerts", e)
+        []
+      end
+
+      # Report metrics from agent (internal use)
+      def report_metrics(host_id:, metrics:, timestamp: nil)
+        response = request(
+          :post,
+          "/internal/agent/report",
+          body: {
+            host_id: host_id,
+            metrics: metrics,
+            timestamp: timestamp || Time.now.utc.iso8601
+          },
+          use_agent_key: true
+        )
+
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
+      rescue StandardError => e
+        log_error("report_metrics", e)
+        false
+      end
+
+      def provision(project_id:, app_name:)
+        response = request(
+          :post,
+          "/api/v1/projects/provision",
+          body: { project_id: project_id, app_name: app_name },
+          use_service_key: true
+        )
+
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated)
+      rescue StandardError => e
+        log_error("provision", e)
+        false
+      end
+
+      private
+
+      def request(method, path, headers: {}, body: nil, params: nil, use_service_key: false, use_agent_key: false)
+        uri = URI.parse("#{@base_url}#{path}")
+
+        if params
+          uri.query = URI.encode_www_form(params)
+        end
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 10
+        http.read_timeout = 30
+
+        request = case method
+        when :get
+          Net::HTTP::Get.new(uri)
+        when :post
+          Net::HTTP::Post.new(uri)
+        when :put
+          Net::HTTP::Put.new(uri)
+        when :delete
+          Net::HTTP::Delete.new(uri)
+        end
+
+        request["Content-Type"] = "application/json"
+        request["Accept"] = "application/json"
+
+        if use_service_key
+          request["X-Service-Key"] = @config.sentinel_master_key || @config.secret_key
+        elsif use_agent_key
+          request["X-Agent-Key"] = @config.sentinel_agent_key || @config.sentinel_api_key || @config.secret_key
+        else
+          auth_key = @config.sentinel_api_key || @config.secret_key
+          request["Authorization"] = "Bearer #{auth_key}" if auth_key
+        end
+
+        headers.each { |k, v| request[k] = v }
+        request.body = body.to_json if body
+
+        http.request(request)
+      end
+
+      def log_error(operation, error)
+        BrainzLab.debug_log("[Sentinel::Client] #{operation} failed: #{error.message}")
+      end
+    end
+  end
+end