activematrix 0.0.5 → 0.0.8

data/lib/active_matrix/event_router.rb

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
 require 'singleton'
-require 'concurrent'
+require 'async'
+require 'async/queue'
 
 module ActiveMatrix
-  # Routes Matrix events to appropriate agents
+  # Routes Matrix events to appropriate agents using async fibers
   class EventRouter
     include Singleton
     include ActiveMatrix::Logging
 
     def initialize
-      @routes = Concurrent::Array.new
-      @event_queue = Queue.new
+      @routes = []
+      @mutex = Mutex.new
+      @event_queue = nil
       @processing = false
-      @worker_thread = nil
+      @worker_task = nil
     end
 
     # Register an event route
@@ -28,8 +30,10 @@ module ActiveMatrix
         handler: block
       }
 
-      @routes << route
-      @routes.sort_by! { |r| -r[:priority] } # Higher priority first
+      @mutex.synchronize do
+        @routes << route
+        @routes.sort_by! { |r| -r[:priority] } # Higher priority first
+      end
 
       logger.debug "Registered route: #{route.except(:handler).inspect}"
       route[:id]
@@ -37,29 +41,35 @@ module ActiveMatrix
 
     # Unregister a route
     def unregister_route(route_id)
-      @routes.delete_if { |route| route[:id] == route_id }
+      @mutex.synchronize do
+        @routes.delete_if { |route| route[:id] == route_id }
+      end
     end
 
     # Clear all routes for an agent
     def clear_agent_routes(agent_id)
-      @routes.delete_if { |route| route[:agent_id] == agent_id }
+      @mutex.synchronize do
+        @routes.delete_if { |route| route[:agent_id] == agent_id }
+      end
     end
 
     # Route an event to appropriate agents
     def route_event(event)
-      return unless @processing
+      return unless @processing && @event_queue
 
       # Queue the event for processing
-      @event_queue << event
+      @event_queue.enqueue(event)
     end
 
-    # Start the event router
+    # Start the event router (call from within async context)
     def start
       return if @processing
 
       @processing = true
-      @worker_thread = Thread.new do
-        Thread.current.name = 'event-router'
+      @event_queue = Async::Queue.new
+
+      @worker_task = Async(transient: true) do |task|
+        task.annotate 'event-router'
         process_events
       end
 
@@ -69,20 +79,22 @@ module ActiveMatrix
     # Stop the event router
     def stop
       @processing = false
-      @worker_thread&.kill
-      @event_queue.clear
+      @worker_task&.stop
+      @event_queue = nil
 
       logger.info 'Event router stopped'
     end
 
     # Check if router is running
     def running?
-      @processing && @worker_thread&.alive?
+      @processing && @worker_task&.alive?
     end
 
     # Get routes for debugging
     def routes_summary
-      @routes.map { |r| r.except(:handler) }
+      @mutex.synchronize do
+        @routes.map { |r| r.except(:handler) }
+      end
     end
 
     # Broadcast an event to all agents
@@ -99,9 +111,7 @@ module ActiveMatrix
     def process_events
       while @processing
         begin
-          # Wait for event with timeout
-          event = nil
-          Timeout.timeout(1) { event = @event_queue.pop }
+          event = @event_queue.dequeue
 
           next unless event
 
@@ -113,36 +123,40 @@ module ActiveMatrix
             next
           end
 
-          # Process routes in priority order
+          # Process routes in priority order (each in its own fiber)
           matching_routes.each do |route|
-            process_route(route, event)
+            Async do
+              process_route(route, event)
+            end
           end
-        rescue Timeout::Error
-          # Normal timeout, continue loop
+        rescue Async::Stop
+          break
         rescue StandardError => e
           logger.error "Event router error: #{e.message}"
-          logger.error e.backtrace.join("\n")
+          logger.error e.backtrace.first(10).join("\n")
         end
       end
     end
 
     def find_matching_routes(event)
-      @routes.select do |route|
-        # Check room match
-        next false if route[:room_id] && route[:room_id] != event[:room_id]
+      @mutex.synchronize do
+        @routes.select do |route|
+          # Check room match
+          next false if route[:room_id] && route[:room_id] != event[:room_id]
 
-        # Check event type match
-        next false if route[:event_type] && route[:event_type] != event[:type]
+          # Check event type match
+          next false if route[:event_type] && route[:event_type] != event[:type]
 
-        # Check user match
-        next false if route[:user_id] && route[:user_id] != event[:sender]
+          # Check user match
+          next false if route[:user_id] && route[:user_id] != event[:sender]
 
-        # Check if agent is running
-        registry = AgentRegistry.instance
-        agent_entry = registry.get(route[:agent_id])
-        next false unless agent_entry
+          # Check if agent is running
+          registry = AgentRegistry.instance
+          agent_entry = registry.get(route[:agent_id])
+          next false unless agent_entry
 
-        true
+          true
+        end
       end
     end
 
@@ -154,18 +168,16 @@ module ActiveMatrix
 
       bot = agent_entry[:instance]
 
-      begin
-        if route[:handler]
-          # Custom handler
-          route[:handler].call(bot, event)
-        elsif bot.respond_to?(:_handle_event)
-          # Default handling
-          bot._handle_event(event)
-        end
-      rescue StandardError => e
-        logger.error "Error processing route for agent #{agent_entry[:record].name}: #{e.message}"
-        logger.error e.backtrace.first(5).join("\n")
+      if route[:handler]
+        # Custom handler
+        route[:handler].call(bot, event)
+      elsif bot.respond_to?(:_handle_event)
+        # Default handling
+        bot._handle_event(event)
       end
+    rescue StandardError => e
+      logger.error "Error processing route for agent #{agent_entry[:record].name}: #{e.message}"
+      logger.error e.backtrace.first(5).join("\n")
     end
   end
 

data/lib/active_matrix/events.rb

@@ -3,6 +3,7 @@
 module ActiveMatrix
   class EventHandlerArray < Hash
     include ActiveMatrix::Logging
+
     attr_accessor :reraise_exceptions
 
     def initialize(*)

data/lib/active_matrix/instrumentation.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/notifications'
+require 'timeout'
+require 'socket'
+require 'json'
+
+module ActiveMatrix
+  # Instrumentation module for Matrix bot operations
+  # Provides ActiveSupport::Notifications events and structured logging
+  #
+  # @example Include in a class
+  #   class MyService
+  #     include ActiveMatrix::Instrumentation
+  #
+  #     def perform
+  #       instrument_operation(:my_operation, room_id: '!abc:matrix.org') do
+  #         # ... operation code
+  #       end
+  #     end
+  #   end
+  #
+  module Instrumentation
+    extend ActiveSupport::Concern
+
+    private
+
+    # Instrument a Matrix bot operation with timing and result tracking
+    #
+    # @param operation [Symbol, String] Operation name (e.g., :send_message, :sync)
+    # @param metadata [Hash] Additional context to include in the event
+    # @yield Block to execute and instrument
+    # @return [Object] Result of the block
+    # @raise [StandardError] Re-raises any exception after logging
+    def instrument_operation(operation, **metadata)
+      event_data = metadata.merge(
+        operation: operation,
+        agent_id: respond_to?(:agent_id) ? agent_id : nil,
+        component: self.class.name&.demodulize || 'Unknown'
+      )
+
+      ActiveSupport::Notifications.instrument(
+        "activematrix.#{operation}",
+        event_data
+      ) do |payload|
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        begin
+          result = yield
+
+          payload[:status] = 'success'
+          payload[:duration_ms] = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+          payload[:result] = summarize_result(result)
+
+          log_operation_result(operation, 'SUCCESS', payload)
+
+          result
+        rescue StandardError => e
+          payload[:status] = 'error'
+          payload[:duration_ms] = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+          payload[:error_class] = e.class.name
+          payload[:error_message] = e.message
+          payload[:error_category] = classify_error(e)
+
+          log_operation_result(operation, 'ERROR', payload)
+
+          raise
+        end
+      end
+    end
+
+    # Classify errors for better monitoring and alerting
+    #
+    # @param error [StandardError] The error to classify
+    # @return [String] Error category
+    def classify_error(error)
+      case error
+      when Timeout::Error
+        'timeout'
+      when SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH
+        'network'
+      when JSON::ParserError
+        'parse'
+      when OpenSSL::SSL::SSLError
+        'ssl'
+      else
+        case error.class.name
+        when /ActiveMatrix::Errors::MatrixConnectionError/
+          'matrix_connection'
+        when /ActiveMatrix::Errors::MatrixRequestError/
+          'matrix_request'
+        when /ActiveMatrix::Errors::MatrixNotAuthorizedError/
+          'matrix_auth'
+        when /ActiveMatrix::Errors::MatrixForbiddenError/
+          'matrix_forbidden'
+        when /ActiveMatrix::Errors::MatrixNotFoundError/
+          'matrix_not_found'
+        when /PG::/
+          'database'
+        else
+          'application'
+        end
+      end
+    end
+
+    # Log operation result with structured data
+    #
+    # @param operation [Symbol, String] Operation name
+    # @param status [String] 'SUCCESS' or 'ERROR'
+    # @param data [Hash] Event payload data
+    def log_operation_result(operation, status, data)
+      component = data[:component] || 'Unknown'
+      agent_id = data[:agent_id] || 'unknown'
+
+      message = "#{operation} - #{status}"
+      message += " (#{data[:duration_ms]}ms)" if data[:duration_ms]
+      message = "[#{component}][agent:#{agent_id}] #{message}"
+
+      if status == 'ERROR'
+        ActiveMatrix.logger.error("#{message}: #{data[:error_class]} - #{data[:error_message]}")
+      else
+        ActiveMatrix.logger.debug(message)
+      end
+    end
+
+    # Summarize result for logging without exposing sensitive data
+    #
+    # @param result [Object] The result to summarize
+    # @return [String] Human-readable summary
+    def summarize_result(result)
+      case result
+      when String
+        result.length > 100 ? "#{result[0...97]}..." : result
+      when Numeric, true, false
+        result.to_s
+      when nil
+        'nil'
+      when Hash
+        "Hash(#{result.keys.size} keys)"
+      when Array
+        "Array(#{result.size} items)"
+      else
+        result.class.name
+      end
+    end
+  end
+end

data/lib/active_matrix/memory/agent_memory.rb

@@ -14,19 +14,15 @@ module ActiveMatrix
       # Get a value from agent memory
       def get(key)
         fetch_with_cache(key) do
-          return nil unless defined?(::AgentMemory)
-
-          memory = @agent.agent_memories.active.find_by(key: key)
+          memory = @agent.agent_stores.active.find_by(key: key)
           memory&.value
         end
       end
 
       # Set a value in agent memory
       def set(key, value, expires_in: nil)
-        return false unless defined?(::AgentMemory)
-
         write_through(key, value, expires_in: expires_in) do
-          memory = @agent.agent_memories.find_or_initialize_by(key: key)
+          memory = @agent.agent_stores.find_or_initialize_by(key: key)
           memory.value = value
           memory.expires_at = expires_in.present? ? Time.current + expires_in : nil
           memory.save!
@@ -35,43 +31,33 @@ module ActiveMatrix
 
       # Check if a key exists
       def exists?(key)
-        return false unless defined?(::AgentMemory)
-
         if @cache_enabled && Rails.cache.exist?(cache_key(key))
           true
         else
-          @agent.agent_memories.active.exists?(key: key)
+          @agent.agent_stores.active.exists?(key: key)
         end
       end
 
       # Delete a key
       def delete(key)
-        return false unless defined?(::AgentMemory)
-
         delete_through(key) do
-          @agent.agent_memories.where(key: key).destroy_all.any?
+          @agent.agent_stores.where(key: key).destroy_all.any?
         end
       end
 
       # Get all keys
       def keys
-        return [] unless defined?(::AgentMemory)
-
-        @agent.agent_memories.active.pluck(:key)
+        AsyncQuery.async_pluck(@agent.agent_stores.active, :key)
       end
 
       # Get all memory as hash
       def all
-        return {} unless defined?(::AgentMemory)
-
-        @agent.agent_memories.active.pluck(:key, :value).to_h
+        AsyncQuery.async_pluck(@agent.agent_stores.active, :key, :value).to_h
       end
 
       # Clear all agent memory
       def clear!
-        return false unless defined?(::AgentMemory)
-
-        @agent.agent_memories.destroy_all
+        @agent.agent_stores.destroy_all
 
         # Clear cache entries
         keys.each { |key| Rails.cache.delete(cache_key(key)) } if @cache_enabled

data/lib/active_matrix/memory/conversation_memory.rb

@@ -16,8 +16,6 @@ module ActiveMatrix
       # Get conversation context
       def context
         fetch_with_cache('context', expires_in: 1.hour) do
-          return {} unless defined?(::ConversationContext)
-
           record = find_or_create_record
           record.context
         end
@@ -25,8 +23,6 @@ module ActiveMatrix
 
       # Update conversation context
       def update_context(data)
-        return false unless defined?(::ConversationContext)
-
         record = find_or_create_record
         record.context = record.context.merge(data)
         record.save!
@@ -38,8 +34,6 @@ module ActiveMatrix
 
       # Add a message to history
       def add_message(event)
-        return false unless defined?(::ConversationContext)
-
         record = find_or_create_record
         record.add_message({
                              event_id: event[:event_id],
@@ -60,8 +54,6 @@ module ActiveMatrix
       # Get recent messages
       def recent_messages(limit = 10)
         fetch_with_cache('recent_messages', expires_in: 5.minutes) do
-          return [] unless defined?(::ConversationContext)
-
           record = find_or_create_record
           record.recent_messages(limit)
         end
@@ -69,8 +61,6 @@ module ActiveMatrix
 
       # Get last message timestamp
       def last_message_at
-        return nil unless defined?(::ConversationContext)
-
         record = conversation_record
         record&.last_message_at
       end
@@ -83,8 +73,6 @@ module ActiveMatrix
 
       # Clear conversation history but keep context
       def clear_history!
-        return false unless defined?(::ConversationContext)
-
         record = conversation_record
         return false unless record
 
@@ -131,20 +119,16 @@ module ActiveMatrix
       end
 
       def conversation_record
-        return nil unless defined?(::ConversationContext)
-
-        ::ConversationContext.find_by(
-          matrix_agent: @agent,
+        ActiveMatrix::ChatSession.find_by(
+          agent: @agent,
           user_id: @user_id,
           room_id: @room_id
         )
       end
 
       def find_or_create_record
-        return nil unless defined?(::ConversationContext)
-
-        ::ConversationContext.find_or_create_by!(
-          matrix_agent: @agent,
+        ActiveMatrix::ChatSession.find_or_create_by!(
+          agent: @agent,
           user_id: @user_id,
           room_id: @room_id
         )

data/lib/active_matrix/memory/global_memory.rb

@@ -11,74 +11,59 @@ module ActiveMatrix
       # Get a value from global memory
       def get(key)
         fetch_with_cache(key) do
-          return nil unless defined?(::GlobalMemory)
-
-          ::GlobalMemory.get(key)
+          ActiveMatrix::KnowledgeBase.get(key)
         end
       end
 
       # Set a value in global memory
       def set(key, value, category: nil, expires_in: nil, public_read: true, public_write: false)
-        return false unless defined?(::GlobalMemory)
-
         write_through(key, value, expires_in: expires_in) do
-          ::GlobalMemory.set(key, value,
-                             category: category,
-                             expires_in: expires_in,
-                             public_read: public_read,
-                             public_write: public_write)
+          ActiveMatrix::KnowledgeBase.set(key, value,
+                                          category: category,
+                                          expires_in: expires_in,
+                                          public_read: public_read,
+                                          public_write: public_write)
         end
       end
 
       # Check if a key exists
       def exists?(key)
-        return false unless defined?(::GlobalMemory)
-
         if @cache_enabled && Rails.cache.exist?(cache_key(key))
           true
         else
-          ::GlobalMemory.active.exists?(key: key)
+          ActiveMatrix::KnowledgeBase.active.exists?(key: key)
         end
       end
 
       # Delete a key
       def delete(key)
-        return false unless defined?(::GlobalMemory)
-
         delete_through(key) do
-          ::GlobalMemory.where(key: key).destroy_all.any?
+          ActiveMatrix::KnowledgeBase.where(key: key).destroy_all.any?
         end
       end
 
       # Get all keys in a category
       def keys(category: nil)
-        return [] unless defined?(::GlobalMemory)
-
-        scope = ::GlobalMemory.active
+        scope = ActiveMatrix::KnowledgeBase.active
         scope = scope.by_category(category) if category
-        scope.pluck(:key)
+        AsyncQuery.async_pluck(scope, :key)
       end
 
       # Get all values in a category
       def by_category(category)
-        return {} unless defined?(::GlobalMemory)
-
-        ::GlobalMemory.active.by_category(category).pluck(:key, :value).to_h
+        scope = ActiveMatrix::KnowledgeBase.active.by_category(category)
+        AsyncQuery.async_pluck(scope, :key, :value).to_h
       end
 
       # Check if readable by agent
       def readable?(key, agent = nil)
-        return false unless defined?(::GlobalMemory)
-
-        memory = ::GlobalMemory.find_by(key: key)
+        memory = ActiveMatrix::KnowledgeBase.find_by(key: key)
         memory&.readable_by?(agent)
       end
 
       # Check if writable by agent
       def writable?(key, agent = nil)
-        return false unless defined?(::GlobalMemory)
-
-        memory = ::GlobalMemory.find_by(key: key)
+        memory = ActiveMatrix::KnowledgeBase.find_by(key: key)
         memory&.writable_by?(agent)
       end
 
@@ -92,7 +77,7 @@ module ActiveMatrix
       # Set with permission check
       def set_for_agent(key, value, agent, **)
         # Allow creating new keys or updating writable ones
-        memory = ::GlobalMemory.find_by(key: key)
+        memory = ActiveMatrix::KnowledgeBase.find_by(key: key)
         return false if memory && !memory.writable_by?(agent)
 
         set(key, value, **)