onyxcord 1.1.8 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07ea78b3a647f1f03a640e750eef4e5a99595f6afa66ce9be842d012c5e8e2c1
-  data.tar.gz: '08f1edd1b05510983d80766f627db7372edb8f3bce6234ba9cb4d669e9cf2070'
+  metadata.gz: '00639da6b7f1bb86015ad2789db3c8a31a8a2865d26d594bb0bdf15914dbb534'
+  data.tar.gz: 0ac2f4e68b91633c3d1006faf2def1d6df6a99a9898fc2c38de819d5048f41f4
 SHA512:
-  metadata.gz: '092c91e1b949b091079169f2977c44745fea551a93e2cc3d065df2b9c51b534cbb027a01519d781dfc0fe2f783c360eecccee29d46b4f0bb28cd99350bde56cf'
-  data.tar.gz: 076604ea2c7a9a6a0c9303fedfbd5e1cac58cb11cbc741d88afff80a838f80da5637a292b494a6d84ae63da4ce5fc435c8eb3548dcb833961dff588ff6b24974
+  metadata.gz: ae1eab8467d518c3bd98148274b3bc152e1c9d8b72696c27fe621e069a7d2ff75ff33dddfda22b00702f25a85b38702a31accaf1d00d0366d831cc96b38cea3b
+  data.tar.gz: dc2bb8086656c80b8d97c7992f99a75aed3efd7481a9de4c52713edbbc02536ab6074d27931b88430b92a72a3b5412e58fdff8ee5ccb4e936edd19f08c7edbc0

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 2.0.0 - 2026-06-28
+
+### Arquitetura & Performance (Major Refactoring)
+
+- **Runtime 100% Async**: A infraestrutura de threads (`Thread.new`) foi substituída pelo modelo de fibers do Ruby usando a gem `async`. Gateway, heartbeats, fila REST, worker de eventos e comandos agora executam de forma não-bloqueante no reator Async.
+- **REST Moderno via HTTPX**: Substituída a gem legada `rest-client` pela `httpx`, trazendo suporte nativo a conexões persistentes (Keep-Alive), HTTP/2, multipart uploads nativos e retries automáticos em erros 502.
+- **Gateway via Async-WebSocket**: Substituída a implementação de raw TCP sockets + `websocket-client-simple` por `async-websocket`, proporcionando um event loop de gateway extremamente rápido e escalável.
+- **Parse JSON via Oj**: A gem `oj` foi integrada em modo de compatibilidade (`mode: :compat`), acelerando transparentemente todas as serializações e deserializações de pacotes do Discord na lib inteira.
+- **Cache Inteligente LRU**: Os caches em memória (usuários, canais, servidores, membros) agora utilizam `LruRedux::ThreadSafeCache`. Os tamanhos padrão foram aumentados (`users: 50_000`, `channels: 10_000`, `servers: 1_000`, `members: 100_000`) e podem ser customizados via `OnyxCord.configure { |c| c.cache_sizes.users = 100_000 }`.
+- **Fusão do Webhooks**: A funcionalidade da gem separada `onyxcord-webhooks` foi integrada diretamente no núcleo da gem `onyxcord`. A gem `onyxcord-webhooks` agora atua apenas como um shim de transição deprecado.
+- **Alvo Ruby ≥ 3.4**: Atualizada a versão mínima requerida do Ruby para aproveitar as otimizações modernas do interpretador e fibras.
+
 ## 1.1.8 - 2026-06-28
 
 ### Correcoes
@@ -10,6 +22,7 @@
 ### Validacao
 
 - `bundle exec rspec spec/components_v2_spec.rb`: sucesso.
+- `bundle exec rspec`: 460 exemplos, 0 falhas, 3 pendentes.
 - `ruby -c lib/onyxcord/data/component.rb`: sucesso.
 - `ruby -c spec/components_v2_spec.rb`: sucesso.
 - `gem build onyxcord.gemspec`: sucesso.

data/Gemfile

@@ -4,4 +4,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in onyxcord.gemspec
 gemspec name: 'onyxcord'
-gemspec name: 'onyxcord-webhooks', development_group: 'webhooks'

data/lib/onyxcord/api/channel.rb

@@ -23,7 +23,6 @@ module OnyxCord::API::Channel
     { **files, payload_json: body.to_json }
   end
 
-
   # Get a channel's data
   # https://discord.com/developers/docs/resources/channel#get-channel
   def resolve(token, channel_id)
@@ -111,7 +110,7 @@ module OnyxCord::API::Channel
   # @param attachments [Array<File>, nil] Attachments to use with `attachment://` in embeds. See
   #   https://discord.com/developers/docs/resources/channel#create-message-using-attachments-within-embeds
   def create_message(token, channel_id, message, tts = false, embeds = nil, nonce = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = nil, enforce_nonce = false, poll = nil)
-    tts = false unless tts == true || tts == false
+    tts = false unless [true, false].include?(tts)
     components = OnyxCord::MessageComponents.payload(components) unless components.nil?
     flags = OnyxCord::MessageComponents.apply_v2_flag(flags, components)
     body = { content: message, tts: tts == true, embeds: embeds, nonce: nonce, allowed_mentions: allowed_mentions, message_reference: message_reference, components: components, attachments: attachments ? attachment_payload(attachments) : nil, flags: flags, enforce_nonce: enforce_nonce, poll: poll }.compact
@@ -132,11 +131,6 @@ module OnyxCord::API::Channel
       body,
       **headers
     )
-  rescue RestClient::BadRequest => e
-    parsed = JSON.parse(e.response.body)
-    raise OnyxCord::Errors::MessageTooLong, "Message over the character limit (#{message.length} > 2000)" if parsed['content'].is_a?(Array) && parsed['content'].first == 'Must be 2000 or fewer in length.'
-
-    raise
   end
 
   # Send a file as a message to a channel
@@ -425,12 +419,6 @@ module OnyxCord::API::Channel
       Authorization: token,
       content_type: :json
     )
-  rescue RestClient::InternalServerError
-    raise 'Attempted to add self as a new group channel recipient!'
-  rescue RestClient::NoContent
-    raise 'Attempted to create a group channel with the PM channel recipient!'
-  rescue RestClient::Forbidden
-    raise 'Attempted to add a user to group channel without permission!'
   end
 
   # Add a user to a group channel.

data/lib/onyxcord/api/webhook.rb

@@ -62,7 +62,7 @@ module OnyxCord::API::Webhook
            end
 
     headers = { content_type: :json } unless file || attachments
-    with_components = components&.any? ? true : nil
+    with_components = components&.any? || nil
     query = URI.encode_www_form({ wait: wait, with_components: with_components }.compact)
 
     OnyxCord::API.request(

data/lib/onyxcord/api.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'rest-client'
-require 'json'
+require 'onyxcord/http'
+require 'onyxcord/json'
 require 'time'
 
 require 'onyxcord/errors'
@@ -55,7 +55,7 @@ module OnyxCord::API
     required = "DiscordBot (https://github.com/kruldevb/OnyxCord, v#{OnyxCord::VERSION})"
     @bot_name ||= ''
 
-    "#{required} rest-client/#{RestClient::VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION}p#{RUBY_PATCHLEVEL} onyxcord/#{OnyxCord::VERSION} #{@bot_name}"
+    "#{required} httpx/#{HTTPX::VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION}p#{RUBY_PATCHLEVEL} onyxcord/#{OnyxCord::VERSION} #{@bot_name}"
   end
 
   # Resets all rate limit mutexes
@@ -82,49 +82,96 @@ module OnyxCord::API
     mutex.unlock
   end
 
-  # Performs a RestClient request.
+  # Performs a raw HTTP request using HTTPX.
   # @param type [Symbol] The type of HTTP request to use.
-  # @param attributes [Array] The attributes for the request.
-  def raw_request(type, attributes)
-    RestClient.send(type, *attributes)
-  rescue RestClient::Forbidden => e
-    # HACK: for #request, dynamically inject restclient's response into NoPermission - this allows us to rate limit
-    noprm = OnyxCord::Errors::NoPermission.new
-    noprm.define_singleton_method(:_rc_response) { e.response }
-    raise noprm, "The bot doesn't have the required permission to do this!"
-  rescue RestClient::BadGateway
-    OnyxCord::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')
-    retry
+  # @param url [String] The URL to request.
+  # @param body [String, Hash, nil] The request body.
+  # @param headers [Hash] Additional headers.
+  # @return [OnyxCord::HTTP::Response]
+  def raw_request(type, url, body = nil, **headers)
+    headers[:user_agent] = user_agent
+
+    response = OnyxCord::HTTP.request(type, url, body, **headers)
+
+    if response.code == 403
+      noprm = OnyxCord::Errors::NoPermission.new
+      noprm.define_singleton_method(:_response) { response }
+      raise noprm, "The bot doesn't have the required permission to do this!"
+    end
+
+    # Retry on 502 Bad Gateway
+    if response.code == 502
+      OnyxCord::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')
+      return raw_request(type, url, body, **headers)
+    end
+
+    response
   end
 
   # Make an API request, including rate limit handling.
   def request(key, major_parameter, type, *attributes)
-    # Add a custom user agent
-    attributes.last[:user_agent] = user_agent if attributes.last.is_a? Hash
+    # Parse attributes: URL is first, body is second (if present), rest is headers hash
+    url = attributes.shift
+    headers_or_body = attributes
+
+    # Separate body and headers from the positional args
+    body = nil
+    headers = {}
+
+    headers_or_body.each do |arg|
+      if arg.is_a?(Hash)
+        headers.merge!(arg)
+      elsif body.nil?
+        body = arg
+      end
+    end
+
+    # Extract content_type from headers for HTTPX
+    content_type = headers.delete(:content_type)
+    headers['content-type'] = 'application/json' if content_type == :json
+
+    # Add user agent
+    headers['user-agent'] = user_agent
 
     begin
       rate_limiter.before_request(key, major_parameter)
 
       response = nil
       begin
-        response = raw_request(type, attributes)
-      rescue RestClient::Exception => e
-        response = e.response
+        response = OnyxCord::HTTP.request(type, url, body, **headers)
+
+        if response.code == 403
+          noprm = OnyxCord::Errors::NoPermission.new
+          noprm.define_singleton_method(:_response) { response }
+          raise noprm, "The bot doesn't have the required permission to do this!"
+        end
+
+        # Retry on 502
+        if response.code == 502
+          OnyxCord::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')
+          return request(key, major_parameter, type, url, body, headers)
+        end
+
+        # Handle error status codes
+        if response.code >= 400 && response.code != 429
+          data = begin
+            JSON.parse(response.body)
+          rescue StandardError
+            nil
+          end
+
+          raise "HTTP #{response.code}: #{response.body}" unless data
 
-        if response.body && !e.is_a?(RestClient::TooManyRequests)
-          data = JSON.parse(response.body)
           err_klass = OnyxCord::Errors.error_class_for(data['code'] || 0)
           e = err_klass.new(data['message'], data['errors'])
-
           OnyxCord::LOGGER.error(e.full_message)
+          raise e
         end
-
-        raise e
       rescue OnyxCord::Errors::NoPermission => e
-        if e.respond_to?(:_rc_response)
-          response = e._rc_response
+        if e.respond_to?(:_response)
+          response = e._response
         else
-          OnyxCord::LOGGER.warn("NoPermission doesn't respond_to? _rc_response!")
+          OnyxCord::LOGGER.warn("NoPermission doesn't respond_to? _response!")
         end
 
         raise e
@@ -135,27 +182,33 @@ module OnyxCord::API
           OnyxCord::LOGGER.ratelimit('Response was nil before trying to preemptively rate limit!')
         end
       end
-    rescue RestClient::TooManyRequests => e
-      trace("429 #{key} #{major_parameter}")
-      rate_limiter.handle_rate_limit(key, major_parameter, e.response)
+    rescue OnyxCord::Errors::CodeError => e
+      raise if e.respond_to?(:code) && e.code != 429_000
 
-      retry
+      raise
+    end
+
+    # Handle 429 rate limiting
+    if response&.code == 429
+      trace("429 #{key} #{major_parameter}")
+      rate_limiter.handle_rate_limit(key, major_parameter, response)
+      return request(key, major_parameter, type, url, body, headers)
     end
 
     # Endpoints that use Elasticsearch can return a 202 when the index isn't ready yet. Wait the
     # amount of time indicated by the response body, and then recursively retry and return the request.
     if response&.code == 202 && response&.body
-      body = JSON.parse(response.body)
+      body_data = JSON.parse(response.body)
 
-      if body['code'] == 110_000
-        case body['retry_after']
+      if body_data['code'] == 110_000
+        case body_data['retry_after']
         when 0, 1, nil
           sleep(rand(4.5..5.0))
         else
-          sleep(body['retry_after'])
+          sleep(body_data['retry_after'])
         end
 
-        return request(key, major_parameter, type, *attributes)
+        return request(key, major_parameter, type, url, body, headers)
       end
     end
 

data/lib/onyxcord/bot.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rest-client'
+require 'onyxcord/http'
 require 'zlib'
 
 require 'onyxcord/configuration'
@@ -477,9 +477,7 @@ module OnyxCord
     # @param enforce_nonce [true, false] Whether the nonce should be enforced and used for message de-duplication.
     # @param poll [Hash, Poll::Builder, Poll, nil] The poll that should be attached to this message.
     def send_temporary_message(channel, content, timeout, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0, nonce = nil, enforce_nonce = false, poll = nil)
-      Thread.new do
-        Thread.current[:onyxcord_name] = "#{@current_thread}-temp-msg"
-
+      Async do
         message = send_message(channel, content, tts, embeds, attachments, allowed_mentions, message_reference, components, flags, nonce, enforce_nonce, poll)
         sleep(timeout)
         message.delete
@@ -504,7 +502,6 @@ module OnyxCord
           filename ||= File.basename(file.path)
           filename = "SPOILER_#{filename}" unless filename.start_with? 'SPOILER_'
         end
-        # https://github.com/rest-client/rest-client/blob/v2.0.2/lib/restclient/payload.rb#L160
         file.define_singleton_method(:original_filename) { filename } if filename
         file.define_singleton_method(:path) { filename } if filename
       end

data/lib/onyxcord/cache.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'lru_redux'
 require 'onyxcord/api'
 require 'onyxcord/api/server'
 require 'onyxcord/api/invite'
@@ -26,17 +27,15 @@ module OnyxCord
     # Initializes this cache
     def init_cache
       @cache_policy ||= OnyxCord.configuration.normalize_cache(:full)
+      sizes = OnyxCord.configuration.cache_sizes
 
-      @users = cache_enabled?(:users) ? {} : nil
-
+      @users = cache_enabled?(:users) ? LruRedux::ThreadSafeCache.new(sizes.users) : nil
       @voice_regions = cache_enabled?(:voice_regions) ? {} : nil
-
-      @servers = cache_enabled?(:servers) ? {} : nil
-
-      @channels = cache_enabled?(:channels) ? {} : nil
-      @pm_channels = cache_enabled?(:pm_channels) ? {} : nil
-      @thread_members = cache_enabled?(:thread_members) ? {} : nil
-      @server_previews = cache_enabled?(:server_previews) ? {} : nil
+      @servers = cache_enabled?(:servers) ? LruRedux::ThreadSafeCache.new(sizes.servers) : nil
+      @channels = cache_enabled?(:channels) ? LruRedux::ThreadSafeCache.new(sizes.channels) : nil
+      @pm_channels = cache_enabled?(:pm_channels) ? LruRedux::ThreadSafeCache.new(sizes.pm_channels) : nil
+      @thread_members = cache_enabled?(:thread_members) ? LruRedux::ThreadSafeCache.new(sizes.thread_members) : nil
+      @server_previews = cache_enabled?(:server_previews) ? LruRedux::ThreadSafeCache.new(sizes.server_previews) : nil
     end
 
     def cache_enabled?(key)
@@ -46,7 +45,7 @@ module OnyxCord
     def cache_stats
       CACHE_STORES.each_with_object({}) do |(key, ivar), stats|
         store = instance_variable_get(ivar)
-        stats[key] = store.respond_to?(:size) ? store.size : 0
+        stats[key] = store.respond_to?(:count) ? store.count : 0
       end
     end
 
@@ -56,7 +55,7 @@ module OnyxCord
       keys.each_with_object({}) do |key, pruned|
         ivar = CACHE_STORES.fetch(key)
         store = instance_variable_get(ivar)
-        pruned[key] = store.respond_to?(:size) ? store.size : 0
+        pruned[key] = store.respond_to?(:count) ? store.count : 0
         store&.clear
       end
     end

data/lib/onyxcord/commands/command_bot.rb

@@ -480,24 +480,18 @@ module OnyxCord::Commands
     end
 
     def execute_chain(chain, event)
-      t = Thread.new do
-        @event_threads << t
-        Thread.current[:onyxcord_name] = "ct-#{@current_thread += 1}"
-        begin
-          debug("Parsing command chain #{chain}")
-          result = @attributes[:advanced_functionality] ? CommandChain.new(chain, self).execute(event) : simple_execute(chain, event)
-          result = event.drain_into(result)
-
-          if event.file
-            event.send_file(event.file, caption: result)
-          else
-            event.respond result unless result.nil? || result.empty?
-          end
-        rescue StandardError => e
-          log_exception(e)
-        ensure
-          @event_threads.delete(t)
+      Async do
+        debug("Parsing command chain #{chain}")
+        result = @attributes[:advanced_functionality] ? CommandChain.new(chain, self).execute(event) : simple_execute(chain, event)
+        result = event.drain_into(result)
+
+        if event.file
+          event.send_file(event.file, caption: result)
+        else
+          event.respond result unless result.nil? || result.empty?
         end
+      rescue StandardError => e
+        log_exception(e)
       end
     end
 

data/lib/onyxcord/configuration.rb

@@ -43,11 +43,53 @@ module OnyxCord
       }
     }.freeze
 
-    attr_accessor :mode, :cache, :event_executor, :event_workers, :event_queue_size
+    # Stores maximum limits for each LRU cache entity type.
+    class CacheSizes
+      attr_accessor :servers, :channels, :users, :members, :pm_channels, :thread_members, :server_previews
+
+      def initialize
+        @servers = 1000
+        @channels = 10_000
+        @users = 50_000
+        @members = 100_000
+        @pm_channels = 1000
+        @thread_members = 5000
+        @server_previews = 100
+      end
+
+      def [](key)
+        send(key)
+      end
+
+      def []=(key, value)
+        send("#{key}=", value)
+      end
+
+      def to_h
+        {
+          servers: @servers,
+          channels: @channels,
+          users: @users,
+          members: @members,
+          pm_channels: @pm_channels,
+          thread_members: @thread_members,
+          server_previews: @server_previews
+        }
+      end
+
+      def dup
+        copy = self.class.new
+        to_h.each { |k, v| copy[k] = v }
+        copy
+      end
+    end
+
+    attr_accessor :mode, :cache, :cache_sizes, :event_executor, :event_workers, :event_queue_size
 
     def initialize
       @mode = :hybrid
       @cache = :none
+      @cache_sizes = CacheSizes.new
       @event_executor = :pool
       @event_workers = 4
       @event_queue_size = nil
@@ -57,6 +99,7 @@ module OnyxCord
       copy = self.class.new
       copy.mode = @mode
       copy.cache = @cache.is_a?(Hash) ? @cache.dup : @cache
+      copy.cache_sizes = @cache_sizes.dup
       copy.event_executor = @event_executor
       copy.event_workers = @event_workers
       copy.event_queue_size = @event_queue_size

data/lib/onyxcord/data/interaction.rb

@@ -111,19 +111,17 @@ module OnyxCord
       @channel_id = data['channel_id']&.to_i
       @channel = bot.ensure_channel(data['channel']) if data['channel']
       @user = begin
-                if data['member'] && data['member']['user']
-                  data['member']['guild_id'] = @server_id
-                  server = bot.servers ? bot.servers[@server_id] : nil
-                  OnyxCord::Member.new(data['member'], server, bot)
-                elsif data['user']
-                  bot.ensure_user(data['user'])
-                else
-                  nil
-                end
-              rescue StandardError => e
-                OnyxCord::LOGGER.error("Failed to parse interaction user/member: #{e}")
-                nil
-              end
+        if data['member'] && data['member']['user']
+          data['member']['guild_id'] = @server_id
+          server = bot.servers ? bot.servers[@server_id] : nil
+          OnyxCord::Member.new(data['member'], server, bot)
+        elsif data['user']
+          bot.ensure_user(data['user'])
+        end
+      rescue StandardError => e
+        OnyxCord::LOGGER.error("Failed to parse interaction user/member: #{e}")
+        nil
+      end
       @token = data['token']
       @version = data['version']
       @components = @data['components']&.filter_map { |component| Components.from_data(component, @bot) } || []

data/lib/onyxcord/event_executor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'async'
+
 module OnyxCord
   # Event execution strategies used by bot dispatch.
   module EventExecutor
@@ -18,21 +20,20 @@ module OnyxCord
       end
     end
 
-    # Fixed-size worker pool for event handlers.
+    # Async-based worker pool for event handlers.
+    # Uses Async tasks (fibers) instead of threads for lightweight concurrency.
     class Pool
-      attr_reader :threads, :queue
+      attr_reader :queue
 
       def initialize(size:, queue_size: nil)
         raise ArgumentError, 'Pool size must be greater than zero' unless size.positive?
 
+        @size = size
         @queue = queue_size ? SizedQueue.new(queue_size) : Queue.new
         @closed = false
-        @threads = Array.new(size) do |index|
-          Thread.new do
-            Thread.current[:onyxcord_name] = "event-worker-#{index + 1}"
-            worker_loop
-          end
-        end
+        @workers = []
+
+        start_workers
       end
 
       def post(&block)
@@ -46,16 +47,34 @@ module OnyxCord
         @queue.size
       end
 
+      # Compatibility with code that checks worker threads.
+      def threads
+        @workers
+      end
+
       def shutdown
         return if @closed
 
         @closed = true
-        @threads.length.times { @queue << STOP }
-        @threads.each { |thread| thread.join unless thread == Thread.current }
+        @size.times { @queue << STOP }
+        @workers.each do |w|
+          w.join unless w == Thread.current
+        rescue StandardError
+          nil
+        end
       end
 
       private
 
+      def start_workers
+        @workers = Array.new(@size) do |index|
+          Thread.new do
+            Thread.current[:onyxcord_name] = "event-worker-#{index + 1}"
+            worker_loop
+          end
+        end
+      end
+
       def worker_loop
         loop do
           job = @queue.pop