brainzlab 0.1.11 → 0.1.12

data/lib/brainzlab/dendrite/client.rb

@@ -223,7 +223,27 @@ module BrainzLab
       end
 
       def log_error(operation, error)
-        BrainzLab.debug_log("[Dendrite::Client] #{operation} failed: #{error.message}")
+        structured_error = ErrorHandler.wrap(error, service: 'Dendrite', operation: operation)
+        BrainzLab.debug_log("[Dendrite::Client] #{operation} failed: #{structured_error.message}")
+
+        # Call on_error callback if configured
+        if @config.on_error
+          @config.on_error.call(structured_error, { service: 'Dendrite', operation: operation })
+        end
+      end
+
+      def handle_response_error(response, operation)
+        return if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated) || response.is_a?(Net::HTTPNoContent) || response.is_a?(Net::HTTPAccepted)
+
+        structured_error = ErrorHandler.from_response(response, service: 'Dendrite', operation: operation)
+        BrainzLab.debug_log("[Dendrite::Client] #{operation} failed: #{structured_error.message}")
+
+        # Call on_error callback if configured
+        if @config.on_error
+          @config.on_error.call(structured_error, { service: 'Dendrite', operation: operation })
+        end
+
+        structured_error
       end
     end
   end

data/lib/brainzlab/development/logger.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module BrainzLab
+  module Development
+    # Pretty-prints development mode events to stdout
+    class Logger
+      # ANSI color codes
+      COLORS = {
+        reset: "\e[0m",
+        bold: "\e[1m",
+        dim: "\e[2m",
+        # Services
+        recall: "\e[36m",     # Cyan
+        reflex: "\e[31m",     # Red
+        pulse: "\e[33m",      # Yellow
+        flux: "\e[35m",       # Magenta
+        signal: "\e[32m",     # Green
+        vault: "\e[34m",      # Blue
+        vision: "\e[95m",     # Light magenta
+        cortex: "\e[96m",     # Light cyan
+        beacon: "\e[92m",     # Light green
+        nerve: "\e[93m",      # Light yellow
+        dendrite: "\e[94m",   # Light blue
+        sentinel: "\e[91m",   # Light red
+        synapse: "\e[97m",    # White
+        # Log levels
+        debug: "\e[37m",      # Gray
+        info: "\e[32m",       # Green
+        warn: "\e[33m",       # Yellow
+        error: "\e[31m",      # Red
+        fatal: "\e[35m"       # Magenta
+      }.freeze
+
+      def initialize(output: $stdout, colors: nil)
+        @output = output
+        @colors = colors.nil? ? tty? : colors
+      end
+
+      # Log an event to stdout in a readable format
+      # @param service [Symbol] :recall, :reflex, :pulse, etc.
+      # @param event_type [String] type of event
+      # @param payload [Hash] event data
+      def log(service:, event_type:, payload:)
+        timestamp = Time.now.strftime('%H:%M:%S.%L')
+        service_color = COLORS[service] || COLORS[:reset]
+
+        # Build the log line
+        parts = []
+        parts << colorize("[#{timestamp}]", :dim)
+        parts << colorize("[#{service.to_s.upcase}]", service_color, bold: true)
+        parts << colorize(event_type, :bold)
+
+        # Add message or name depending on event type
+        message = extract_message(payload, event_type)
+        parts << message if message
+
+        # Print the main line
+        @output.puts parts.join(' ')
+
+        # Print additional details indented
+        print_details(payload, event_type)
+      end
+
+      private
+
+      def tty?
+        @output.respond_to?(:tty?) && @output.tty?
+      end
+
+      def colorize(text, color, bold: false)
+        return text unless @colors
+
+        color_code = color.is_a?(Symbol) ? COLORS[color] : color
+        prefix = bold ? "#{COLORS[:bold]}#{color_code}" : color_code.to_s
+        "#{prefix}#{text}#{COLORS[:reset]}"
+      end
+
+      def extract_message(payload, event_type)
+        case event_type
+        when 'log'
+          level = payload[:level]&.to_sym
+          level_color = COLORS[level] || COLORS[:info]
+          msg = "#{colorize("[#{level&.upcase}]", level_color)} #{payload[:message]}"
+          msg
+        when 'error'
+          "#{payload[:error_class]}: #{payload[:message]}"
+        when 'trace'
+          duration = payload[:duration_ms] ? "(#{payload[:duration_ms]}ms)" : ''
+          "#{payload[:name]} #{duration}"
+        when 'metric'
+          "#{payload[:name]} = #{payload[:value]}"
+        when 'span'
+          duration = payload[:duration_ms] ? "(#{payload[:duration_ms]}ms)" : ''
+          "#{payload[:name]} #{duration}"
+        else
+          payload[:message] || payload[:name]
+        end
+      end
+
+      def print_details(payload, event_type)
+        details = extract_details(payload, event_type)
+        return if details.empty?
+
+        details.each do |key, value|
+          formatted_value = format_value(value)
+          @output.puts "  #{colorize(key.to_s, :dim)}: #{formatted_value}"
+        end
+      end
+
+      def extract_details(payload, event_type)
+        # Fields to exclude from details (already shown in main line)
+        excluded = %i[timestamp message level name kind]
+
+        case event_type
+        when 'log'
+          payload.except(*excluded, :environment, :service, :host)
+        when 'error'
+          payload.slice(:error_class, :environment, :request_id, :user, :tags).compact
+        when 'trace'
+          payload.slice(:request_method, :request_path, :status, :db_ms, :view_ms, :spans).compact
+        when 'metric'
+          payload.slice(:kind, :tags).compact
+        else
+          payload.except(*excluded)
+        end
+      end
+
+      def format_value(value)
+        case value
+        when Hash
+          if value.size <= 3
+            value.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
+          else
+            "\n    #{JSON.pretty_generate(value).gsub("\n", "\n    ")}"
+          end
+        when Array
+          if value.size <= 3 && value.all? { |v| v.is_a?(String) || v.is_a?(Numeric) }
+            value.inspect
+          else
+            "\n    #{JSON.pretty_generate(value).gsub("\n", "\n    ")}"
+          end
+        else
+          value.inspect
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/development/store.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'sqlite3'
+require 'json'
+require 'fileutils'
+
+module BrainzLab
+  module Development
+    # SQLite-backed store for development mode events
+    class Store
+      DEFAULT_PATH = 'tmp/brainzlab.sqlite3'
+
+      def initialize(config)
+        @config = config
+        @db_path = config.development_db_path || DEFAULT_PATH
+        @db = nil
+        ensure_database!
+      end
+
+      # Insert an event into the store
+      # @param service [Symbol] :recall, :reflex, :pulse, etc.
+      # @param event_type [String] type of event
+      # @param payload [Hash] event data
+      def insert(service:, event_type:, payload:)
+        db.execute(
+          'INSERT INTO events (service, event_type, payload, created_at) VALUES (?, ?, ?, ?)',
+          [service.to_s, event_type.to_s, JSON.generate(payload), Time.now.utc.iso8601(3)]
+        )
+      end
+
+      # Query events from the store
+      # @param service [Symbol, nil] filter by service
+      # @param event_type [String, nil] filter by event type
+      # @param since [Time, nil] filter events after this time
+      # @param limit [Integer] max number of events to return
+      # @return [Array<Hash>] matching events
+      def query(service: nil, event_type: nil, since: nil, limit: 100)
+        conditions = []
+        params = []
+
+        if service
+          conditions << 'service = ?'
+          params << service.to_s
+        end
+
+        if event_type
+          conditions << 'event_type = ?'
+          params << event_type.to_s
+        end
+
+        if since
+          conditions << 'created_at >= ?'
+          params << since.utc.iso8601(3)
+        end
+
+        where_clause = conditions.empty? ? '' : "WHERE #{conditions.join(' AND ')}"
+        params << limit
+
+        sql = "SELECT id, service, event_type, payload, created_at FROM events #{where_clause} ORDER BY created_at DESC LIMIT ?"
+
+        db.execute(sql, params).map do |row|
+          {
+            id: row[0],
+            service: row[1].to_sym,
+            event_type: row[2],
+            payload: JSON.parse(row[3], symbolize_names: true),
+            created_at: Time.parse(row[4])
+          }
+        end
+      end
+
+      # Get event counts by service
+      def stats
+        results = db.execute('SELECT service, COUNT(*) as count FROM events GROUP BY service')
+        results.to_h { |row| [row[0].to_sym, row[1]] }
+      end
+
+      # Clear all events
+      def clear!
+        db.execute('DELETE FROM events')
+      end
+
+      # Close the database connection
+      def close
+        @db&.close
+        @db = nil
+      end
+
+      private
+
+      def db
+        @db ||= begin
+          SQLite3::Database.new(@db_path).tap do |database|
+            database.results_as_hash = false
+          end
+        end
+      end
+
+      def ensure_database!
+        # Ensure the directory exists
+        FileUtils.mkdir_p(File.dirname(@db_path))
+
+        # Create the events table if it doesn't exist
+        db.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            service TEXT NOT NULL,
+            event_type TEXT NOT NULL,
+            payload TEXT NOT NULL,
+            created_at TEXT NOT NULL
+          )
+        SQL
+
+        # Create indexes for common queries
+        db.execute('CREATE INDEX IF NOT EXISTS idx_events_service ON events(service)')
+        db.execute('CREATE INDEX IF NOT EXISTS idx_events_event_type ON events(event_type)')
+        db.execute('CREATE INDEX IF NOT EXISTS idx_events_created_at ON events(created_at)')
+      end
+    end
+  end
+end

data/lib/brainzlab/development.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'development/store'
+require_relative 'development/logger'
+
+module BrainzLab
+  # Development mode support for offline SDK usage
+  # Logs all events to stdout and stores them locally in SQLite
+  module Development
+    class << self
+      # Check if development mode is enabled
+      def enabled?
+        BrainzLab.configuration.mode == :development
+      end
+
+      # Get the store instance
+      def store
+        @store ||= Store.new(BrainzLab.configuration)
+      end
+
+      # Get the development logger
+      def logger
+        @logger ||= Logger.new(output: BrainzLab.configuration.development_log_output || $stdout)
+      end
+
+      # Record an event from any service
+      # @param service [Symbol] :recall, :reflex, :pulse, etc.
+      # @param event_type [String] type of event (log, error, trace, metric, etc.)
+      # @param payload [Hash] event data
+      def record(service:, event_type:, payload:)
+        return unless enabled?
+
+        # Log to stdout
+        logger.log(service: service, event_type: event_type, payload: payload)
+
+        # Store in SQLite
+        store.insert(service: service, event_type: event_type, payload: payload)
+      end
+
+      # Query stored events
+      # @param service [Symbol, nil] filter by service
+      # @param event_type [String, nil] filter by event type
+      # @param since [Time, nil] filter events after this time
+      # @param limit [Integer] max number of events to return (default: 100)
+      # @return [Array<Hash>] matching events
+      def events(service: nil, event_type: nil, since: nil, limit: 100)
+        return [] unless enabled?
+
+        store.query(service: service, event_type: event_type, since: since, limit: limit)
+      end
+
+      # Clear all stored events
+      def clear!
+        store.clear! if enabled?
+      end
+
+      # Reset the development module (for testing)
+      def reset!
+        @store&.close
+        @store = nil
+        @logger = nil
+      end
+
+      # Get event counts by service
+      def stats
+        return {} unless enabled?
+
+        store.stats
+      end
+    end
+  end
+end