whodunit-chronicles 0.3.0 → 0.4.0

data/lib/whodunit/chronicles/adapters/mysql.rb

@@ -1,261 +0,0 @@
-# frozen_string_literal: true
-
-require 'trilogy'
-require 'uri'
-
-module Whodunit
-  module Chronicles
-    module Adapters
-      # MySQL/MariaDB binary log streaming adapter
-      #
-      # Uses MySQL's binary log replication to stream database changes
-      # without impacting application performance.
-      class MySQL < Chronicles::StreamAdapter
-        DEFAULT_SERVER_ID = 1001
-
-        attr_reader :connection, :database_url, :server_id, :binlog_file, :binlog_position
-
-        def initialize(
-          database_url: Chronicles.config.database_url,
-          server_id: DEFAULT_SERVER_ID,
-          logger: Chronicles.logger
-        )
-          super(logger: logger)
-          @database_url = database_url
-          @server_id = server_id
-          @connection = nil
-          @binlog_file = nil
-          @binlog_position = nil
-          @binlog_checksum = true
-        end
-
-        # Start streaming binary log changes
-        def start_streaming(&)
-          raise ArgumentError, 'Block required for processing events' unless block_given?
-
-          log(:info, 'Starting MySQL binary log streaming')
-
-          establish_connection
-          ensure_setup
-
-          self.running = true
-          fetch_current_position
-
-          log(:info, 'Starting replication from position',
-            file: @binlog_file, position: @binlog_position)
-
-          begin
-            stream_binlog_events(&)
-          rescue StandardError => e
-            log(:error, 'Streaming error', error: e.message, backtrace: e.backtrace.first(5))
-            raise ReplicationError, "Failed to stream changes: #{e.message}"
-          ensure
-            self.running = false
-          end
-        end
-
-        # Stop streaming
-        def stop_streaming
-          log(:info, 'Stopping MySQL binary log streaming')
-          self.running = false
-          close_connection
-        end
-
-        # Get current replication position
-        def current_position
-          return "#{@binlog_file}:#{@binlog_position}" if @binlog_file && @binlog_position
-
-          fetch_current_position
-          "#{@binlog_file}:#{@binlog_position}"
-        end
-
-        # Set up binary log replication
-        def setup
-          log(:info, 'Setting up MySQL binary log replication')
-
-          establish_connection
-          validate_binlog_format
-          validate_server_id
-          enable_binlog_checksum
-
-          log(:info, 'MySQL setup completed successfully')
-        end
-
-        # Remove binary log replication setup (minimal cleanup needed)
-        def teardown
-          log(:info, 'Tearing down MySQL binary log replication')
-          close_connection
-          log(:info, 'MySQL teardown completed')
-        end
-
-        # Test database connection
-        def test_connection
-          establish_connection
-          result = @connection.query('SELECT @@hostname, @@version, @@server_id')
-          info = result.first
-
-          log(:info, 'Connection test successful',
-            hostname: info['@@hostname'],
-            version: info['@@version'],
-            server_id: info['@@server_id'])
-
-          true
-        rescue StandardError => e
-          log(:error, 'Connection test failed', error: e.message)
-          false
-        end
-
-        private
-
-        def establish_connection
-          return if @connection&.ping
-
-          parsed_url = parse_database_url(@database_url)
-
-          @connection = Trilogy.new(
-            host: parsed_url[:host],
-            port: parsed_url[:port] || 3306,
-            username: parsed_url[:username],
-            password: parsed_url[:password],
-            database: parsed_url[:database],
-            ssl: parsed_url[:ssl],
-          )
-
-          log(:debug, 'Established MySQL connection',
-            host: parsed_url[:host],
-            database: parsed_url[:database])
-        rescue StandardError => e
-          log(:error, 'Failed to establish connection', error: e.message)
-          raise AdapterLoadError, "Connection failed: #{e.message}"
-        end
-
-        def close_connection
-          @connection&.close
-          @connection = nil
-        end
-
-        def parse_database_url(url)
-          uri = URI.parse(url)
-          {
-            host: uri.host,
-            port: uri.port,
-            username: uri.user,
-            password: uri.password,
-            database: uri.path&.sub('/', ''),
-            ssl: uri.query&.include?('ssl=true'),
-          }
-        end
-
-        def ensure_setup
-          validate_binlog_format
-          validate_server_id
-        end
-
-        def validate_binlog_format
-          result = @connection.query('SELECT @@binlog_format')
-          format = result.first['@@binlog_format']
-
-          unless %w[ROW MIXED].include?(format)
-            raise ReplicationError,
-              "Binary log format must be ROW or MIXED, currently: #{format}"
-          end
-
-          log(:debug, 'Binary log format validated', format: format)
-        end
-
-        def validate_server_id
-          result = @connection.query('SELECT @@server_id')
-          current_server_id = result.first['@@server_id'].to_i
-
-          if current_server_id == @server_id
-            raise ReplicationError,
-              "Server ID conflict: #{@server_id} is already in use"
-          end
-
-          log(:debug, 'Server ID validated',
-            current: current_server_id,
-            replication: @server_id)
-        end
-
-        def enable_binlog_checksum
-          @connection.query('SET @master_binlog_checksum = @@global.binlog_checksum')
-          log(:debug, 'Binary log checksum enabled')
-        end
-
-        def fetch_current_position
-          result = @connection.query('SHOW MASTER STATUS')
-          status = result.first
-
-          raise ReplicationError, 'Unable to fetch master status - binary logging may be disabled' unless status
-
-          @binlog_file = status['File']
-          @binlog_position = status['Position']
-          log(:debug, 'Fetched master position',
-            file: @binlog_file,
-            position: @binlog_position)
-        end
-
-        def stream_binlog_events(&)
-          # Register as replica server
-          register_replica_server
-
-          # Request binary log dump
-          request_binlog_dump
-
-          # Process binary log events
-          process_binlog_stream(&)
-        rescue StandardError => e
-          log(:error, 'Binary log streaming error', error: e.message)
-          raise
-        end
-
-        def register_replica_server
-          # This would typically use COM_REGISTER_SLAVE MySQL protocol command
-          # For now, we'll use a simplified approach
-          log(:debug, 'Registering as replica server', server_id: @server_id)
-
-          # NOTE: Full implementation would require low-level MySQL protocol handling
-          # This is a placeholder for the binary log streaming setup
-        end
-
-        def request_binlog_dump
-          log(:debug, 'Requesting binary log dump',
-            file: @binlog_file,
-            position: @binlog_position)
-
-          # This would use COM_BINLOG_DUMP MySQL protocol command
-          # Full implementation requires binary protocol handling
-        end
-
-        def process_binlog_stream(&)
-          # This would process the binary log event stream
-          # Each event would be parsed and converted to a ChangeEvent
-
-          log(:info, 'Processing binary log stream (placeholder implementation)')
-
-          # Placeholder: In a real implementation, this would:
-          # 1. Read binary log events from the stream
-          # 2. Parse event headers and data
-          # 3. Convert to ChangeEvent objects
-          # 4. Yield each event to the block
-
-          # For now, we'll simulate with a warning
-          log(:warn, 'MySQL binary log streaming requires full protocol implementation')
-
-          # Yield a placeholder change event to demonstrate the interface
-          change_event = ChangeEvent.new(
-            table_name: 'example_table',
-            action: 'INSERT',
-            primary_key: { id: 1 },
-            new_data: { id: 1, name: 'test' },
-            old_data: nil,
-            timestamp: Time.now,
-            metadata: { position: current_position },
-          )
-
-          yield(change_event) if block_given?
-        end
-      end
-    end
-  end
-end

data/lib/whodunit/chronicles/adapters/postgresql.rb

@@ -1,278 +0,0 @@
-# frozen_string_literal: true
-
-require 'pg'
-
-module Whodunit
-  module Chronicles
-    module Adapters
-      # PostgreSQL logical replication adapter
-      #
-      # Uses PostgreSQL's logical replication functionality to stream
-      # database changes via WAL decoding without impacting application performance.
-      class PostgreSQL < Chronicles::StreamAdapter
-        DEFAULT_PLUGIN = 'pgoutput'
-
-        attr_reader :connection, :replication_connection, :publication_name, :slot_name
-
-        def initialize(
-          database_url: Chronicles.config.database_url,
-          publication_name: Chronicles.config.publication_name,
-          slot_name: Chronicles.config.replication_slot_name,
-          logger: Chronicles.logger
-        )
-          super(logger: logger)
-          @database_url = database_url
-          @publication_name = publication_name
-          @slot_name = slot_name
-          @connection = nil
-          @replication_connection = nil
-          @last_lsn = nil
-        end
-
-        # Start streaming logical replication changes
-        def start_streaming(&)
-          raise ArgumentError, 'Block required for processing events' unless block_given?
-
-          log(:info, 'Starting PostgreSQL logical replication streaming')
-
-          establish_connections
-          ensure_setup
-
-          self.running = true
-          self.position = confirmed_flush_lsn || '0/0'
-
-          log(:info, 'Starting replication from LSN', lsn: @position)
-
-          begin
-            stream_changes(&)
-          rescue StandardError => e
-            log(:error, 'Streaming error', error: e.message, backtrace: e.backtrace.first(5))
-            raise ReplicationError, "Failed to stream changes: #{e.message}"
-          ensure
-            self.running = false
-          end
-        end
-
-        # Stop streaming
-        def stop_streaming
-          log(:info, 'Stopping PostgreSQL logical replication streaming')
-          self.running = false
-          close_connections
-        end
-
-        # Get current replication position
-        def current_position
-          @last_lsn || confirmed_flush_lsn
-        end
-
-        # Set up logical replication (publication and slot)
-        def setup
-          log(:info, 'Setting up PostgreSQL logical replication')
-
-          establish_connection
-          create_publication
-          create_replication_slot
-
-          log(:info, 'PostgreSQL setup completed successfully')
-        end
-
-        # Remove logical replication setup
-        def teardown
-          log(:info, 'Tearing down PostgreSQL logical replication')
-
-          establish_connection
-          drop_replication_slot
-          drop_publication
-
-          log(:info, 'PostgreSQL teardown completed')
-        ensure
-          close_connections
-        end
-
-        # Test database connection
-        def test_connection
-          establish_connection
-          result = @connection.exec('SELECT current_database(), current_user, version()')
-          db_info = result.first
-
-          log(:info, 'Connection test successful',
-            database: db_info['current_database'],
-            user: db_info['current_user'],
-            version: db_info['version'])
-
-          true
-        rescue PG::Error => e
-          log(:error, 'Connection test failed', error: e.message)
-          false
-        ensure
-          result&.clear
-        end
-
-        private
-
-        def establish_connections
-          establish_connection
-          establish_replication_connection
-        end
-
-        def establish_connection
-          return if @connection && !@connection.finished?
-
-          @connection = PG.connect(@database_url)
-          @connection.type_map_for_results = PG::BasicTypeMapForResults.new(@connection)
-        end
-
-        def establish_replication_connection
-          return if @replication_connection && !@replication_connection.finished?
-
-          # Parse connection URL and add replication parameter
-          uri = URI.parse(@database_url)
-          repl_params = URI.decode_www_form(uri.query || '')
-          repl_params << %w[replication database]
-          uri.query = URI.encode_www_form(repl_params)
-
-          @replication_connection = PG.connect(uri.to_s)
-        end
-
-        def close_connections
-          @connection&.close
-          @replication_connection&.close
-          @connection = nil
-          @replication_connection = nil
-        end
-
-        def ensure_setup
-          unless publication_exists?
-            raise ReplicationError, "Publication '#{publication_name}' does not exist. Run #setup first."
-          end
-
-          return if replication_slot_exists?
-
-          raise ReplicationError, "Replication slot '#{slot_name}' does not exist. Run #setup first."
-        end
-
-        def stream_changes(&)
-          copy_sql = build_copy_statement
-          log(:debug, 'Starting COPY command', sql: copy_sql)
-
-          @replication_connection.exec(copy_sql)
-
-          while running?
-            data = @replication_connection.get_copy_data(async: false)
-            break unless data
-
-            process_wal_data(data, &)
-          end
-        end
-
-        def build_copy_statement
-          options = [
-            "proto_version '1'",
-            "publication_names '#{publication_name}'",
-          ].join(', ')
-
-          "COPY (SELECT * FROM pg_logical_slot_get_changes('#{slot_name}', NULL, NULL, #{options})) TO STDOUT"
-        end
-
-        def process_wal_data(data)
-          # Parse pgoutput protocol message
-          # This is a simplified version - full implementation would need
-          # to properly decode the binary protocol
-          log(:debug, 'Processing WAL data', size: data.bytesize)
-
-          # For now, we'll parse text-based logical decoding output
-          # In production, this should parse the binary pgoutput format
-          change_event = parse_logical_message(data)
-          yield(change_event) if change_event
-        rescue StandardError => e
-          log(:error, 'Error processing WAL data', error: e.message, data: data.inspect)
-        end
-
-        def parse_logical_message(data)
-          # Simplified parser for demonstration
-          # Real implementation would parse pgoutput binary protocol
-          lines = data.strip.split("\n")
-          return unless lines.any?
-
-          # This is a placeholder - would need full pgoutput protocol parsing
-          log(:debug, 'Parsed logical message', lines: lines.size)
-          nil
-        end
-
-        def create_publication
-          if publication_exists?
-            log(:info, 'Publication already exists', name: publication_name)
-            return
-          end
-
-          sql = "CREATE PUBLICATION #{publication_name} FOR ALL TABLES"
-          @connection.exec(sql)
-          log(:info, 'Created publication', name: publication_name)
-        end
-
-        def drop_publication
-          return unless publication_exists?
-
-          sql = "DROP PUBLICATION IF EXISTS #{publication_name}"
-          @connection.exec(sql)
-          log(:info, 'Dropped publication', name: publication_name)
-        end
-
-        def create_replication_slot
-          if replication_slot_exists?
-            log(:info, 'Replication slot already exists', name: slot_name)
-            return
-          end
-
-          sql = "SELECT pg_create_logical_replication_slot('#{slot_name}', '#{DEFAULT_PLUGIN}')"
-          result = @connection.exec(sql)
-          slot_info = result.first
-
-          log(:info, 'Created replication slot',
-            name: slot_name,
-            lsn: slot_info['lsn'])
-        ensure
-          result&.clear
-        end
-
-        def drop_replication_slot
-          return unless replication_slot_exists?
-
-          sql = "SELECT pg_drop_replication_slot('#{slot_name}')"
-          @connection.exec(sql)
-          log(:info, 'Dropped replication slot', name: slot_name)
-        end
-
-        def publication_exists?
-          sql = 'SELECT 1 FROM pg_publication WHERE pubname = $1'
-          result = @connection.exec_params(sql, [publication_name])
-          exists = result.ntuples.positive?
-          result.clear
-          exists
-        end
-
-        def replication_slot_exists?
-          sql = 'SELECT 1 FROM pg_replication_slots WHERE slot_name = $1'
-          result = @connection.exec_params(sql, [slot_name])
-          exists = result.ntuples.positive?
-          result.clear
-          exists
-        end
-
-        def confirmed_flush_lsn
-          sql = 'SELECT confirmed_flush_lsn FROM pg_replication_slots WHERE slot_name = $1'
-          result = @connection.exec_params(sql, [slot_name])
-
-          if result.ntuples.positive?
-            lsn = result.first['confirmed_flush_lsn']
-            result.clear
-            lsn
-          else
-            result.clear
-            nil
-          end
-        end
-      end
-    end
-  end
-end