discord_rda 0.1.3 → 0.2.0

data/lib/discord_rda/cache/store.rb

@@ -54,3 +54,5 @@ module DiscordRDA
     def keys(pattern)
       raise NotImplementedError
     end
+  end
+end

data/lib/discord_rda/connection/gateway_client.rb

@@ -3,7 +3,7 @@
 require 'async/websocket'
 require 'async/http/internet'
 require 'async/http/endpoint'
-require 'async/io/stream'
+require 'io/stream'
 require 'zlib'
 
 module DiscordRDA
@@ -52,6 +52,9 @@ module DiscordRDA
     # @return [String] Session ID for resuming
     attr_reader :session_id
 
+    # @return [String, nil] Resume gateway URL
+    attr_reader :resume_gateway_url
+
     # @return [Boolean] Whether connected
     attr_reader :connected
 
@@ -74,7 +77,7 @@ module DiscordRDA
       @heartbeat_task = nil
       @websocket = nil
       @zlib = nil
-      @buffer = +'')
+      @buffer = +''
       @last_heartbeat_ack = Time.now
       @resume_gateway_url = nil
     end
@@ -207,6 +210,13 @@ module DiscordRDA
       send_payload(payload)
     end
 
+    def restore_session_state(session_id:, sequence:, resume_gateway_url: nil)
+      @session_id = session_id
+      @sequence = sequence.to_i
+      @resume_gateway_url = resume_gateway_url if resume_gateway_url
+      @logger&.info('Restored gateway session state', shard: @shard_id, session: @session_id, seq: @sequence)
+    end
+
     private
 
     def fetch_gateway_url

data/lib/discord_rda/connection/rest_client.rb

@@ -4,6 +4,7 @@ require 'async/http/internet'
 require 'async/http/endpoint'
 require 'cgi'
 require 'net/http/post/multipart'
+require 'oj'
 
 module DiscordRDA
   # HTTP client for Discord REST API.
@@ -264,7 +265,7 @@ module DiscordRDA
 
     def handle_response(response)
       body = response.read
-      data = body ? Oj.load(body) : nil
+      data = parse_response_body(body)
 
       case response.status
       when 200..299
@@ -286,6 +287,14 @@ module DiscordRDA
       end
     end
 
+    def parse_response_body(body)
+      return nil if body.nil? || body.empty?
+
+      Oj.load(body)
+    rescue Oj::ParseError
+      body
+    end
+
     # REST API Errors
     class APIError < StandardError
       attr_reader :status, :data, :code, :message

data/lib/discord_rda/connection/rest_proxy.rb

@@ -130,7 +130,11 @@ module DiscordRDA
 
     def handle_response(response)
       body = response.read
-      data = body ? Oj.load(body) : nil
+      data = if body.nil? || body.empty?
+               nil
+             else
+               Oj.load(body)
+             end
 
       case response.status
       when 200..299

data/lib/discord_rda/connection/shard_manager.rb

@@ -30,10 +30,11 @@ module DiscordRDA
     # @param config [Configuration] Bot configuration
     # @param event_bus [EventBus] Event bus instance
     # @param logger [Logger] Logger instance
-    def initialize(config, event_bus, logger)
+    def initialize(config, event_bus, logger, gateway_state: {})
       @config = config
       @event_bus = event_bus
       @logger = logger
+      @gateway_state = gateway_state || {}
       @shard_count = nil
       @shards = []
       @total_guilds = nil
@@ -191,6 +192,14 @@ module DiscordRDA
         shard_count: shard_count
       )
 
+      if (state = @gateway_state[shard_id] || @gateway_state[shard_id.to_s])
+        gateway.restore_session_state(
+          session_id: state['session_id'] || state[:session_id],
+          sequence: state['sequence'] || state[:sequence],
+          resume_gateway_url: state['resume_gateway_url'] || state[:resume_gateway_url]
+        )
+      end
+
       @mutex.synchronize { @shards << gateway }
 
       # Start gateway in background

data/lib/discord_rda/core/configuration.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'json'
+require 'yaml'
+
 module DiscordRDA
   # Immutable configuration for DiscordRDA.
   # Uses frozen hash to prevent mutation after initialization.
@@ -29,7 +32,13 @@ module DiscordRDA
       compression_threshold: 1024,
       intents: [:guilds],
       log_level: :info,
-      log_format: :structured
+      log_format: :structured,
+      log_output: :stdout,
+      log_file_path: nil,
+      log_rotate_age: 7,
+      log_rotate_size: 10_485_760,
+      trace_enabled: false,
+      error_tracking: false
     }.freeze
 
     # Valid intents mapping
@@ -108,6 +117,18 @@ module DiscordRDA
     # @return [Symbol] Log format (:simple, :structured)
     attr_reader :log_format
 
+    attr_reader :log_output
+
+    attr_reader :log_file_path
+
+    attr_reader :log_rotate_age
+
+    attr_reader :log_rotate_size
+
+    attr_reader :trace_enabled
+
+    attr_reader :error_tracking
+
     # Create a new configuration
     # @param options [Hash] Configuration options
     def initialize(options = {})
@@ -133,10 +154,20 @@ module DiscordRDA
       @intents = normalize_intents(config[:intents])
       @log_level = config[:log_level].to_sym
       @log_format = config[:log_format].to_sym
+      @log_output = config[:log_output].is_a?(Symbol) ? config[:log_output] : config[:log_output].to_s
+      @log_file_path = config[:log_file_path]
+      @log_rotate_age = config[:log_rotate_age].to_i
+      @log_rotate_size = config[:log_rotate_size].to_i
+      @trace_enabled = !!config[:trace_enabled]
+      @error_tracking = !!config[:error_tracking]
 
       freeze
     end
 
+    def self.load(path, overrides: {})
+      new(load_file(path).merge(overrides))
+    end
+
     # Calculate the intents bitmask for Gateway identify
     # @return [Integer] Intents bitmask
     def intents_bitmask
@@ -170,12 +201,44 @@ module DiscordRDA
         compression_threshold: @compression_threshold,
         intents: @intents,
         log_level: @log_level,
-        log_format: @log_format
+        log_format: @log_format,
+        log_output: @log_output,
+        log_file_path: @log_file_path,
+        log_rotate_age: @log_rotate_age,
+        log_rotate_size: @log_rotate_size,
+        trace_enabled: @trace_enabled,
+        error_tracking: @error_tracking
       }
     end
 
     private
 
+    def self.load_file(path)
+      content = File.read(path)
+
+      case File.extname(path).downcase
+      when '.json'
+        symbolize_keys(JSON.parse(content))
+      when '.yml', '.yaml'
+        symbolize_keys(YAML.safe_load(content, permitted_classes: [Symbol], aliases: true) || {})
+      else
+        raise ArgumentError, "Unsupported configuration file format: #{path}"
+      end
+    end
+
+    def self.symbolize_keys(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, nested_value), hash|
+          hash[key.to_sym] = symbolize_keys(nested_value)
+        end
+      when Array
+        value.map { |item| symbolize_keys(item) }
+      else
+        value
+      end
+    end
+
     def normalize_shards(shards)
       return [:auto] if shards == :auto
       return shards if shards.is_a?(Array) && shards.all? { |s| s.is_a?(Array) }

data/lib/discord_rda/core/error_tracker.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DiscordRDA
+  class ErrorTracker
+    attr_reader :enabled
+
+    def initialize(enabled: false, logger: nil)
+      @enabled = enabled
+      @logger = logger
+    end
+
+    def capture(error, **context)
+      return unless enabled
+
+      if defined?(::Sentry)
+        ::Sentry.capture_exception(error, extra: context)
+      else
+        @logger&.error('Captured error', error: error, **context)
+      end
+    end
+  end
+end

data/lib/discord_rda/core/execution_supervisor.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'rbconfig'
+require 'tempfile'
+require 'timeout'
+
+module DiscordRDA
+  class ExecutionSupervisor
+    DEFAULT_POLICY = {
+      timeout_seconds: 15,
+      max_concurrency: 8,
+      failure_threshold: 5,
+      cooldown_seconds: 60
+    }.freeze
+
+    class TimeoutError < StandardError; end
+    class ConcurrencyLimitError < StandardError; end
+    class CircuitOpenError < StandardError; end
+    class IsolatedExecutionError < StandardError; end
+
+    attr_reader :logger
+
+    def initialize(logger: nil)
+      @logger = logger
+      @states = {}
+      @mutex = Mutex.new
+    end
+
+    def execute(key, policy: {}, &block)
+      merged = DEFAULT_POLICY.merge(policy || {})
+      state = state_for(key)
+
+      raise CircuitOpenError, "Circuit open for #{key}" if circuit_open?(state)
+      acquire_slot!(key, state, merged)
+
+      begin
+        result = ::Timeout.timeout(merged[:timeout_seconds]) { block.call }
+        record_success(state)
+        result
+      rescue ::Timeout::Error => e
+        record_failure(state)
+        raise TimeoutError, e.message
+      rescue StandardError
+        record_failure(state)
+        raise
+      ensure
+        release_slot(state)
+      end
+    end
+
+    def run_isolated(ruby_code:, timeout_seconds: 15, memory_limit_mb: nil, env: {})
+      Tempfile.create(['discord_rda_isolated', '.rb']) do |file|
+        file.write(build_isolated_runner(ruby_code, memory_limit_mb))
+        file.flush
+
+        stdout, stderr, status = spawn_with_timeout(
+          [RbConfig.ruby, file.path],
+          timeout_seconds: timeout_seconds,
+          env: env
+        )
+
+        raise IsolatedExecutionError, stderr unless status.success?
+
+        stdout
+      end
+    end
+
+    private
+
+    def state_for(key)
+      @mutex.synchronize do
+        @states[key] ||= {
+          running: 0,
+          failures: 0,
+          opened_at: nil,
+          failure_threshold: DEFAULT_POLICY[:failure_threshold],
+          cooldown_seconds: DEFAULT_POLICY[:cooldown_seconds]
+        }
+      end
+    end
+
+    def circuit_open?(state)
+      @mutex.synchronize do
+        return false unless state[:opened_at]
+
+        if Time.now.to_f - state[:opened_at] >= state[:cooldown_seconds]
+          state[:opened_at] = nil
+          state[:failures] = 0
+          false
+        else
+          true
+        end
+      end
+    end
+
+    def acquire_slot!(key, state, policy)
+      @mutex.synchronize do
+        state[:failure_threshold] = policy[:failure_threshold]
+        state[:cooldown_seconds] = policy[:cooldown_seconds]
+
+        if state[:running] >= policy[:max_concurrency]
+          raise ConcurrencyLimitError, "Concurrency limit reached for #{key}"
+        end
+
+        state[:running] += 1
+      end
+    end
+
+    def release_slot(state)
+      @mutex.synchronize do
+        state[:running] -= 1 if state[:running].positive?
+      end
+    end
+
+    def record_success(state)
+      @mutex.synchronize do
+        state[:failures] = 0
+        state[:opened_at] = nil
+      end
+    end
+
+    def record_failure(state)
+      @mutex.synchronize do
+        state[:failures] += 1
+        if state[:failures] >= state[:failure_threshold]
+          state[:opened_at] = Time.now.to_f
+        end
+      end
+    end
+
+    def spawn_with_timeout(command, timeout_seconds:, env:)
+      stdout_r, stdout_w = IO.pipe
+      stderr_r, stderr_w = IO.pipe
+
+      pid = Process.spawn(env, *command, out: stdout_w, err: stderr_w)
+      stdout_w.close
+      stderr_w.close
+
+      timed_out = false
+      begin
+        ::Timeout.timeout(timeout_seconds) { Process.wait(pid) }
+      rescue ::Timeout::Error
+        timed_out = true
+        Process.kill('KILL', pid) rescue nil
+        Process.wait(pid) rescue nil
+      end
+
+      stdout = stdout_r.read
+      stderr = stderr_r.read
+      stdout_r.close
+      stderr_r.close
+
+      if timed_out
+        raise TimeoutError, "Isolated execution timed out after #{timeout_seconds}s"
+      end
+
+      [stdout, stderr, $CHILD_STATUS]
+    end
+
+    def build_isolated_runner(ruby_code, memory_limit_mb)
+      limit_code = if memory_limit_mb
+        "Process.setrlimit(:AS, #{memory_limit_mb.to_i} * 1024 * 1024)\n"
+      else
+        ''
+      end
+
+      <<~RUBY
+        # frozen_string_literal: true
+        #{limit_code}begin
+          #{ruby_code}
+        rescue StandardError => e
+          warn("#{e.class}: #{e.message}")
+          warn(e.backtrace.join("\\n")) if e.backtrace
+          exit(1)
+        end
+      RUBY
+    end
+  end
+end

data/lib/discord_rda/core/logger.rb

@@ -2,6 +2,7 @@
 
 require 'logger'
 require 'json'
+require 'fileutils'
 
 module DiscordRDA
   # Structured logging for DiscordRDA.
@@ -35,10 +36,10 @@ module DiscordRDA
     # @param level [Symbol] Log level
     # @param format [Symbol] Log format
     # @param output [IO] Output destination (default: STDOUT)
-    def initialize(level: :info, format: :structured, output: STDOUT)
+    def initialize(level: :info, format: :structured, output: STDOUT, file_path: nil, rotate_age: 7, rotate_size: 10_485_760)
       @level = level.to_sym
       @format = format.to_sym
-      @output = output
+      @output = build_output(output, file_path, rotate_age, rotate_size)
       @mutex = Mutex.new
     end
 
@@ -102,11 +103,24 @@ module DiscordRDA
 
     private
 
+    def build_output(output, file_path, rotate_age, rotate_size)
+      return output unless file_path
+
+      FileUtils.mkdir_p(File.dirname(file_path))
+      ::Logger::LogDevice.new(file_path, shift_age: rotate_age, shift_size: rotate_size)
+    end
+
     def log(level, message, context)
       return unless level_enabled?(level)
 
       entry = build_log_entry(level, message, context)
-      @mutex.synchronize { @output.puts(entry) }
+      @mutex.synchronize do
+        if @output.respond_to?(:puts)
+          @output.puts(entry)
+        else
+          @output.write("#{entry}\n")
+        end
+      end
     end
 
     def build_log_entry(level, message, context)

data/lib/discord_rda/core/restart_manager.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'rbconfig'
+require 'securerandom'
+require 'tmpdir'
+
+module DiscordRDA
+  class RestartManager
+    STATE_ENV = 'DISCORD_RDA_RESTART_STATE_PATH'
+
+    attr_reader :logger
+
+    def initialize(logger:)
+      @logger = logger
+      @bot = nil
+    end
+
+    def attach(bot)
+      @bot = bot
+    end
+
+    def consume_boot_state
+      path = ENV.delete(STATE_ENV)
+      return {} unless path && File.exist?(path)
+
+      data = JSON.parse(File.read(path))
+      File.delete(path)
+      logger&.info('Loaded restart state', shards: (data['shards'] || []).length)
+      data
+    rescue StandardError => e
+      logger&.error('Failed to load restart state', error: e)
+      {}
+    end
+
+    def restart!(command: nil, env: {})
+      raise 'Restart manager is not attached to a bot instance' unless @bot
+
+      state_path = write_restart_state
+      restart_command = command || default_command
+
+      logger&.info('Performing instant restart', command: restart_command)
+
+      exec(
+        {
+          STATE_ENV => state_path,
+          'DISCORD_RDA_RESTARTED_AT' => Time.now.utc.iso8601
+        }.merge(env),
+        RbConfig.ruby,
+        *restart_command
+      )
+    end
+
+    private
+
+    def write_restart_state
+      path = File.join(Dir.tmpdir, "discord_rda_restart_#{Process.pid}_#{SecureRandom.hex(6)}.json")
+      File.write(path, JSON.pretty_generate(snapshot_state))
+      path
+    end
+
+    def snapshot_state
+      {
+        pid: Process.pid,
+        written_at: Time.now.utc.iso8601,
+        total_guilds: @bot.shard_manager.total_guilds,
+        shards: @bot.shard_manager.shards.map do |shard|
+          {
+            shard_id: shard.instance_variable_get(:@shard_id),
+            shard_count: shard.instance_variable_get(:@shard_count),
+            session_id: shard.session_id,
+            sequence: shard.sequence,
+            resume_gateway_url: shard.resume_gateway_url
+          }
+        end
+      }
+    end
+
+    def default_command
+      [$PROGRAM_NAME, *ARGV]
+    end
+  end
+end

data/lib/discord_rda/core/secrets.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'yaml'
+
+module DiscordRDA
+  class Secrets
+    def self.fetch(key, default: nil, required: false)
+      value = ENV[key.to_s]
+      if required && (value.nil? || value.empty?)
+        raise KeyError, "Missing required secret: #{key}"
+      end
+
+      value.nil? || value.empty? ? default : value
+    end
+
+    def self.load_file(path)
+      content = File.read(path)
+
+      case File.extname(path).downcase
+      when '.json'
+        JSON.parse(content)
+      when '.yml', '.yaml'
+        YAML.safe_load(content, aliases: true) || {}
+      else
+        raise ArgumentError, "Unsupported secrets file format: #{path}"
+      end
+    end
+  end
+end

data/lib/discord_rda/core/snowflake.rb

@@ -55,7 +55,7 @@ module DiscordRDA
     # Get the timestamp from the snowflake
     # @return [Time] The timestamp (UTC)
     def timestamp
-      @timestamp ||= Time.at(((@value >> 22) + DISCORD_EPOCH) / 1000.0).utc
+      Time.at(((@value >> 22) + DISCORD_EPOCH) / 1000.0).utc
     end
     alias time timestamp
 

data/lib/discord_rda/core/tracer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DiscordRDA
+  class Tracer
+    Span = Struct.new(:name, :attributes, :started_at, :finished_at, :error, keyword_init: true)
+
+    attr_reader :enabled
+
+    def initialize(enabled: false, logger: nil)
+      @enabled = enabled
+      @logger = logger
+    end
+
+    def with_span(name, **attributes)
+      return yield unless enabled
+
+      span = Span.new(name: name, attributes: attributes, started_at: Time.now.utc)
+      if defined?(::OpenTelemetry::Trace)
+        tracer = ::OpenTelemetry.tracer_provider.tracer('discord_rda')
+        tracer.in_span(name, attributes: attributes) { yield }
+      else
+        yield
+      end
+    rescue StandardError => e
+      span.error = e
+      raise
+    ensure
+      if enabled
+
+        span.finished_at = Time.now.utc
+        @logger&.debug(
+          'Trace span',
+          span: span.name,
+          duration_ms: ((span.finished_at - span.started_at) * 1000).round(2),
+          error: span.error&.class&.name,
+          **span.attributes
+        )
+      end
+    end
+  end
+end

data/lib/discord_rda/entity/base.rb

@@ -51,9 +51,16 @@ module DiscordRDA
     # Initialize entity with data
     # @param data [Hash] Entity data
     def initialize(data = {})
-      @id = data['id'] ? Snowflake.new(data['id']) : nil
-      @raw_data = data.freeze
-      freeze
+      normalized_data = data.each_with_object({}) do |(key, value), hash|
+        hash[key.to_s] = value
+      end
+
+      normalized_data.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+
+      @id = normalized_data['id'] ? Snowflake.new(normalized_data['id']) : nil
+      @raw_data = normalized_data.freeze
     end
 
     # Get raw API data

data/lib/discord_rda/entity/message_builder.rb

@@ -367,3 +367,5 @@ module DiscordRDA
       @components << menu
       self
     end
+  end
+end