rubydb 0.1.3 → 0.1.5

data/lib/rubydb/migrations/schema_version.rb

@@ -1,64 +1,64 @@
-# frozen_string_literal: true
-
-require "time"
-require "json"
-
-module RubyDB
-  module Migrations
-    # SchemaVersion - Tracks schema version information
-    class SchemaVersion
-      attr_reader :version, :applied_at, :migration_name
-      attr_reader :description, :author, :checksum
-
-      def initialize(version, migration_name, options = {})
-        @version = version
-        @migration_name = migration_name
-        @description = options[:description] || ""
-        @author = options[:author]
-        @applied_at = Time.now
-        @checksum = options[:checksum]
-        @metadata = options[:metadata] || {}
-        @status = :applied
-        @database_version = options[:database_version]
-      end
-
-      def to_hash
-        {
-          version: @version,
-          migration_name: @migration_name,
-          description: @description,
-          author: @author,
-          applied_at: @applied_at.iso8601,
-          checksum: @checksum,
-          metadata: @metadata,
-          status: @status,
-          database_version: @database_version
-        }
-      end
-
-      def to_json
-        JSON.generate(to_hash)
-      end
-
-      def self.from_json(json_data)
-        data = JSON.parse(json_data, symbolize_names: true)
-        version = new(
-          data[:version],
-          data[:migration_name],
-          description: data[:description],
-          author: data[:author],
-          checksum: data[:checksum],
-          metadata: data[:metadata] || {},
-          database_version: data[:database_version]
-        )
-        version.instance_variable_set(:@applied_at, Time.parse(data[:applied_at]))
-        version.instance_variable_set(:@status, data[:status].to_sym)
-        version
-      end
-
-      def inspect
-        "#<SchemaVersion version=#{@version} migration=#{@migration_name} applied=#{@applied_at}>"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "time"
+require "json"
+
+module RubyDB
+  module Migrations
+    # SchemaVersion - Tracks schema version information
+    class SchemaVersion
+      attr_reader :version, :applied_at, :migration_name
+      attr_reader :description, :author, :checksum
+
+      def initialize(version, migration_name, options = {})
+        @version = version
+        @migration_name = migration_name
+        @description = options[:description] || ""
+        @author = options[:author]
+        @applied_at = Time.now
+        @checksum = options[:checksum]
+        @metadata = options[:metadata] || {}
+        @status = :applied
+        @database_version = options[:database_version]
+      end
+
+      def to_hash
+        {
+          version: @version,
+          migration_name: @migration_name,
+          description: @description,
+          author: @author,
+          applied_at: @applied_at.iso8601,
+          checksum: @checksum,
+          metadata: @metadata,
+          status: @status,
+          database_version: @database_version
+        }
+      end
+
+      def to_json
+        JSON.generate(to_hash)
+      end
+
+      def self.from_json(json_data)
+        data = JSON.parse(json_data, symbolize_names: true)
+        version = new(
+          data[:version],
+          data[:migration_name],
+          description: data[:description],
+          author: data[:author],
+          checksum: data[:checksum],
+          metadata: data[:metadata] || {},
+          database_version: data[:database_version]
+        )
+        version.instance_variable_set(:@applied_at, Time.parse(data[:applied_at]))
+        version.instance_variable_set(:@status, data[:status].to_sym)
+        version
+      end
+
+      def inspect
+        "#<SchemaVersion version=#{@version} migration=#{@migration_name} applied=#{@applied_at}>"
+      end
+    end
+  end
+end

data/lib/rubydb/monitoring/events.rb

@@ -1,160 +1,155 @@
-# 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
+# frozen_string_literal: true
+
+require "time"
+
+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|
+            listener.call(event)
+          rescue
+            @stats[:errors] += 1
+          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
+          loop do
+            event = @queue.pop
+            process_event(event)
+          rescue
+            @stats[:errors] += 1
+          end
+        end
+      end
+    end
+  end
+end