rubydb 0.1.0

data/lib/rubydb/monitoring/events.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "time"
+require "thread"
+
+module RubyDB
+  module Monitoring
+    # Events - Event system
+    class Events
+      attr_reader :stats
+
+      # Event types
+      EVENT_CONNECT = :connect
+      EVENT_DISCONNECT = :disconnect
+      EVENT_QUERY = :query
+      EVENT_TRANSACTION = :transaction
+      EVENT_ERROR = :error
+      EVENT_WARNING = :warning
+      EVENT_CHECKPOINT = :checkpoint
+      EVENT_RECOVERY = :recovery
+      EVENT_REPLICATION = :replication
+      EVENT_BACKUP = :backup
+      EVENT_RESTORE = :restore
+      EVENT_MIGRATION = :migration
+      EVENT_SCHEMA_CHANGE = :schema_change
+      EVENT_SYSTEM = :system
+
+      def initialize(config = {})
+        @config = config
+        @listeners = {}
+        @event_history = []
+        @max_history = config[:max_history] || 10000
+        @lock = Mutex.new
+        @stats = {
+          events_emitted: 0,
+          events_processed: 0,
+          listeners_registered: 0,
+          listeners_removed: 0,
+          errors: 0
+        }
+        @async = config[:async] != false
+        @queue = Queue.new if @async
+        @processor_thread = nil
+
+        start_processor if @async
+      end
+
+      def on(event_type, &block)
+        @lock.synchronize do
+          @listeners[event_type] ||= []
+          @listeners[event_type] << block
+          @stats[:listeners_registered] += 1
+        end
+      end
+
+      def off(event_type, block = nil)
+        @lock.synchronize do
+          return false unless @listeners[event_type]
+
+          if block
+            @listeners[event_type].delete(block)
+          else
+            @listeners[event_type].clear
+          end
+          @stats[:listeners_removed] += 1
+          true
+        end
+      end
+
+      def emit(event_type, data = {})
+        @lock.synchronize do
+          @stats[:events_emitted] += 1
+
+          event = {
+            id: generate_event_id,
+            type: event_type,
+            timestamp: Time.now.iso8601,
+            data: data,
+            pid: Process.pid,
+            thread: Thread.current.object_id
+          }
+
+          @event_history << event
+          if @event_history.size > @max_history
+            @event_history.shift
+          end
+
+          if @async
+            @queue << event
+          else
+            process_event(event)
+          end
+
+          event
+        end
+      end
+
+      def process_event(event)
+        @lock.synchronize do
+          @stats[:events_processed] += 1
+          listeners = @listeners[event[:type]] || []
+          listeners.each do |listener|
+            begin
+              listener.call(event)
+            rescue => e
+              @stats[:errors] += 1
+            end
+          end
+        end
+      end
+
+      def history(event_type = nil)
+        @lock.synchronize do
+          if event_type
+            @event_history.select { |e| e[:type] == event_type }
+          else
+            @event_history.dup
+          end
+        end
+      end
+
+      def clear_history
+        @lock.synchronize do
+          @event_history.clear
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            history_size: @event_history.size,
+            max_history: @max_history,
+            listeners_count: @listeners.size,
+            async: @async,
+            queue_size: @async ? @queue.size : 0
+          })
+        end
+      end
+
+      private
+
+      def generate_event_id
+        "evt_#{Time.now.to_i}_#{rand(10000)}"
+      end
+
+      def start_processor
+        @processor_thread = Thread.new do
+          while true
+            begin
+              event = @queue.pop
+              process_event(event)
+            rescue => e
+              @stats[:errors] += 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/monitoring/health.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Monitoring
+    # Health - Health checking
+    class Health
+      attr_reader :stats
+
+      # Health statuses
+      STATUS_HEALTHY = :healthy
+      STATUS_DEGRADED = :degraded
+      STATUS_UNHEALTHY = :unhealthy
+      STATUS_UNKNOWN = :unknown
+
+      def initialize(engine, config = {})
+        @engine = engine
+        @config = config
+        @checks = {}
+        @status = STATUS_UNKNOWN
+        @last_check = nil
+        @details = {}
+        @stats = {
+          checks_performed: 0,
+          checks_passed: 0,
+          checks_failed: 0,
+          status_changes: 0
+        }
+        @lock = Mutex.new
+        @check_interval = config[:check_interval] || 30
+        @check_thread = nil
+        @running = false
+
+        # Register default checks
+        register_default_checks
+
+        start_check_thread if config[:auto_check] != false
+      end
+
+      def register_check(name, &block)
+        @checks[name] = block
+      end
+
+      def check
+        @lock.synchronize do
+          @stats[:checks_performed] += 1
+          @last_check = Time.now
+          @details = {}
+
+          results = {}
+
+          @checks.each do |name, check|
+            begin
+              result = check.call(@engine)
+              results[name] = result
+              @details[name] = result
+
+              if result[:status] == STATUS_HEALTHY
+                @stats[:checks_passed] += 1
+              else
+                @stats[:checks_failed] += 1
+              end
+            rescue => e
+              results[name] = { status: STATUS_UNHEALTHY, error: e.message }
+              @details[name] = { status: STATUS_UNHEALTHY, error: e.message }
+              @stats[:checks_failed] += 1
+            end
+          end
+
+          # Determine overall status
+          old_status = @status
+          if results.values.all? { |r| r[:status] == STATUS_HEALTHY }
+            @status = STATUS_HEALTHY
+          elsif results.values.any? { |r| r[:status] == STATUS_UNHEALTHY }
+            @status = STATUS_UNHEALTHY
+          else
+            @status = STATUS_DEGRADED
+          end
+
+          if @status != old_status
+            @stats[:status_changes] += 1
+          end
+
+          {
+            status: @status,
+            timestamp: @last_check.iso8601,
+            checks: results
+          }
+        end
+      end
+
+      # Liveness answers whether the monitoring process is responsive. It
+      # deliberately does not touch storage or replication dependencies.
+      def liveness
+        {
+          status: STATUS_HEALTHY,
+          live: true,
+          timestamp: Time.now.iso8601
+        }
+      end
+
+      # Readiness answers whether the database can safely receive work. It
+      # runs the configured dependency checks and never reports ready when a
+      # check is unhealthy.
+      def readiness
+        result = check
+        {
+          status: result[:status],
+          ready: result[:status] == STATUS_HEALTHY,
+          timestamp: result[:timestamp],
+          checks: result[:checks]
+        }
+      end
+
+      def status
+        @status
+      end
+
+      def healthy?
+        @status == STATUS_HEALTHY
+      end
+
+      def degraded?
+        @status == STATUS_DEGRADED
+      end
+
+      def unhealthy?
+        @status == STATUS_UNHEALTHY
+      end
+
+      def details
+        @details.dup
+      end
+
+      def last_check
+        @last_check
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            status: @status,
+            checks_count: @checks.size,
+            last_check: @last_check&.iso8601,
+            running: @running,
+            check_interval: @check_interval
+          })
+        end
+      end
+
+      private
+
+      def register_default_checks
+        register_check("connection") do |engine|
+          if engine.connected?
+            { status: STATUS_HEALTHY, message: "Connected" }
+          else
+            { status: STATUS_UNHEALTHY, message: "Disconnected" }
+          end
+        end
+
+        register_check("storage") do |engine|
+          if engine.storage_available?
+            { status: STATUS_HEALTHY, message: "Storage available" }
+          else
+            { status: STATUS_UNHEALTHY, message: "Storage unavailable" }
+          end
+        end
+
+        register_check("memory") do |engine|
+          if engine.memory_usage < 0.9
+            { status: STATUS_HEALTHY, message: "Memory usage normal" }
+          elsif engine.memory_usage < 0.95
+            { status: STATUS_DEGRADED, message: "Memory usage high" }
+          else
+            { status: STATUS_UNHEALTHY, message: "Memory usage critical" }
+          end
+        end
+
+        register_check("replication") do |engine|
+          if engine.replication_healthy?
+            { status: STATUS_HEALTHY, message: "Replication healthy" }
+          else
+            { status: STATUS_UNHEALTHY, message: "Replication unhealthy" }
+          end
+        end
+
+        register_check("connections") do |engine|
+          usage = engine.connection_usage
+          if usage < 0.8
+            { status: STATUS_HEALTHY, message: "Connection usage normal" }
+          elsif usage < 0.95
+            { status: STATUS_DEGRADED, message: "Connection usage high" }
+          else
+            { status: STATUS_UNHEALTHY, message: "Connection usage critical" }
+          end
+        end
+
+        register_check("wal") do |engine|
+          if engine.wal_healthy?
+            { status: STATUS_HEALTHY, message: "WAL healthy" }
+          else
+            { status: STATUS_UNHEALTHY, message: "WAL unhealthy" }
+          end
+        end
+      end
+
+      def start_check_thread
+        @running = true
+        @check_thread = Thread.new do
+          while @running
+            sleep(@check_interval)
+            begin
+              check
+            rescue => e
+              # Continue running
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/monitoring/logger.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "time"
+require "json"
+require "fileutils"
+
+module RubyDB
+  module Monitoring
+    # Logger - Structured logging
+    class Logger
+      attr_reader :stats
+
+      # Log levels
+      LEVEL_DEBUG = 0
+      LEVEL_INFO = 1
+      LEVEL_WARN = 2
+      LEVEL_ERROR = 3
+      LEVEL_FATAL = 4
+
+      LEVEL_NAMES = {
+        0 => "DEBUG",
+        1 => "INFO",
+        2 => "WARN",
+        3 => "ERROR",
+        4 => "FATAL"
+      }
+
+      def initialize(config = {})
+        @config = config
+        @log_dir = config[:log_dir] || "log"
+        @log_file = config[:log_file] || "rubydb.log"
+        @level = config[:level] || LEVEL_INFO
+        @format = config[:format] || :json
+        @max_size = config[:max_size] || 10 * 1024 * 1024
+        @max_files = config[:max_files] || 10
+        @sync = config[:sync] || false
+        @stats = {
+          logs_written: 0,
+          logs_failed: 0,
+          log_rotations: 0,
+          buffer_size: 0
+        }
+        @buffer = []
+        @buffer_size = config[:buffer_size] || 100
+        @lock = Mutex.new
+        @file = nil
+
+        FileUtils.mkdir_p(@log_dir)
+        open_log_file
+        start_flush_thread if config[:async] != false
+      end
+
+      def debug(message, data = {})
+        log(LEVEL_DEBUG, message, data)
+      end
+
+      def info(message, data = {})
+        log(LEVEL_INFO, message, data)
+      end
+
+      def warn(message, data = {})
+        log(LEVEL_WARN, message, data)
+      end
+
+      def error(message, data = {})
+        log(LEVEL_ERROR, message, data)
+      end
+
+      def fatal(message, data = {})
+        log(LEVEL_FATAL, message, data)
+      end
+
+      def log(level, message, data = {})
+        return if level < @level
+
+        @lock.synchronize do
+          entry = {
+            timestamp: Time.now.iso8601,
+            level: LEVEL_NAMES[level],
+            message: message,
+            data: data,
+            pid: Process.pid,
+            thread: Thread.current.object_id
+          }
+
+          @buffer << entry
+          @stats[:buffer_size] = @buffer.size
+
+          if @buffer.size >= @buffer_size
+            flush
+          end
+        end
+      end
+
+      def flush
+        @lock.synchronize do
+          return if @buffer.empty?
+
+          begin
+            rotate_log if File.size(@log_path) > @max_size
+
+            File.open(@log_path, "a") do |file|
+              @buffer.each do |entry|
+                line = format_entry(entry)
+                file.puts(line)
+              end
+              file.flush if @sync
+            end
+
+            @stats[:logs_written] += @buffer.size
+            @buffer.clear
+            @stats[:buffer_size] = 0
+
+          rescue => e
+            @stats[:logs_failed] += 1
+          end
+        end
+      end
+
+      def close
+        flush
+        @file.close if @file
+      end
+
+      def level=(level)
+        @level = level
+      end
+
+      def level
+        @level
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            level: LEVEL_NAMES[@level],
+            format: @format,
+            buffer_size: @buffer.size,
+            log_path: @log_path,
+            sync: @sync
+          })
+        end
+      end
+
+      private
+
+      def open_log_file
+        @log_path = File.join(@log_dir, @log_file)
+        @file = File.open(@log_path, "a")
+        @file.sync = @sync
+      end
+
+      def rotate_log
+        @file.close if @file
+
+        timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+        archive_path = "#{@log_path}.#{timestamp}"
+        FileUtils.mv(@log_path, archive_path)
+
+        # Remove old archives
+        archives = Dir.glob("#{@log_path}.*").sort
+        while archives.size > @max_files - 1
+          File.delete(archives.shift)
+        end
+
+        open_log_file
+        @stats[:log_rotations] += 1
+      end
+
+      def format_entry(entry)
+        case @format
+        when :json
+          JSON.generate(entry)
+        else
+          "[#{entry[:timestamp]}] #{entry[:level]} [#{entry[:pid]}]: #{entry[:message]}"
+        end
+      end
+
+      def start_flush_thread
+        Thread.new do
+          loop do
+            sleep(1)
+            begin
+              flush
+            rescue => e
+              # Continue running
+            end
+          end
+        end
+      end
+    end
+  end
+end