discorb 0.15.0 → 0.17.0

data/lib/discorb/gateway.rb

@@ -14,12 +14,22 @@ module Discorb
   module Gateway
     #
     # Represents an event.
+    # @abstract
     #
     class GatewayEvent
+      #
+      # Initializes a new instance of the GatewayEvent class.
       # @private
+      #
+      # @param [Hash] data The data of the event.
+      #
       def initialize(data)
         @data = data
       end
+
+      def inspect
+        "#<#{self.class}>"
+      end
     end
 
     #
@@ -61,7 +71,13 @@ module Discorb
       alias reactor fired_by
       alias from fired_by
 
+      #
+      # Initializes a new instance of the ReactionEvent class.
       # @private
+      #
+      # @param [Discorb::Client] client The client that instantiated the object.
+      # @param [Hash] data The data of the event.
+      #
       def initialize(client, data)
         @client = client
         @data = data
@@ -80,7 +96,8 @@ module Discorb
 
         unless @guild.nil?
           @member = if data.key?(:member)
-              @guild.members[data[:member][:user][:id]] || Member.new(@client, @guild_id, data[:member][:user], data[:member])
+              @guild.members[data[:member][:user][:id]] || Member.new(@client, @guild_id, data[:member][:user],
+                                                                      data[:member])
             else
               @guild.members[data[:user_id]]
             end
@@ -114,6 +131,7 @@ module Discorb
     class IntegrationDeleteEvent < GatewayEvent
       # @return [Discorb::Snowflake] The ID of the integration.
       attr_reader :id
+
       # @!attribute [r] guild
       #   @macro client_cache
       #   @return [Discorb::Guild] The guild of the integration.
@@ -121,7 +139,14 @@ module Discorb
       #   @macro client_cache
       #   @return [Discorb::User] The user associated with the integration.
 
+      #
+      # Initialize a new instance of the IntegrationDeleteEvent class.
       # @private
+      #
+      #
+      # @param [Hash] data The data of the event.
+      #
+      #
       def initialize(_client, data)
         @id = Snowflake.new(data[:id])
         @guild_id = data[:guild_id]
@@ -157,7 +182,13 @@ module Discorb
       # @return [Discorb::Message] The message the reaction was sent in.
       attr_reader :message
 
+      #
+      # Initialize a new instance of the ReactionRemoveAllEvent class.
       # @private
+      #
+      # @param [Discorb::Client] client The client that instantiated the object.
+      # @param [Hash] data The data of the event.
+      #
       def initialize(client, data)
         @client = client
         @data = data
@@ -207,7 +238,13 @@ module Discorb
       # @return [Discorb::UnicodeEmoji, Discorb::PartialEmoji] The emoji that was reacted with.
       attr_reader :emoji
 
+      #
+      # Initialize a new instance of the ReactionRemoveEmojiEvent class.
       # @private
+      #
+      # @param [Discorb::Client] client The client that instantiated the object.
+      # @param [Hash] data The data of the event.
+      #
       def initialize(client, data)
         @client = client
         @data = data
@@ -246,7 +283,14 @@ module Discorb
       attr_reader :guild
       # @return [Discorb::ScheduledEvent] The scheduled event.
       attr_reader :scheduled_event
+
+      #
+      # Initialize a new instance of the ScheduledEventUserEvent class.
       # @private
+      #
+      # @param [Discorb::Client] client The client that instantiated the object.
+      # @param [Hash] data The data of the event.
+      #
       def initialize(client, data)
         @client = client
         @scheduled_event_id = Snowflake.new(data[:scheduled_event_id])
@@ -342,7 +386,13 @@ module Discorb
       #   @macro client_cache
       #   @return [Discorb::Guild] The guild the message was sent in.
 
+      #
+      # Initialize a new instance of the UnknownDeleteBulkMessage class.
       # @private
+      #
+      # @param [Discorb::Client] client The client that instantiated the object.
+      # @param [Hash] data The data of the event.
+      #
       def initialize(client, id, data)
         @client = client
         @id = id
@@ -374,7 +424,13 @@ module Discorb
       #   @macro client_cache
       #   @return [Discorb::Guild] The guild the message was sent in.
 
+      #
+      # Initialize a new instance of the InviteDeleteEvent class.
       # @private
+      #
+      # @param [Discorb::Client] client The client that instantiated the object.
+      # @param [Hash] data The data of the event.
+      #
       def initialize(client, data)
         @client = client
         @data = data
@@ -392,21 +448,6 @@ module Discorb
       end
     end
 
-    #
-    # Represents a `GUILD_INTEGRATIONS_UPDATE` event.
-    #
-    class GuildIntegrationsUpdateEvent < GatewayEvent
-      def initialize(client, data)
-        @client = client
-        @data = data
-        @guild_id = Snowflake.new(data[:guild_id])
-      end
-
-      def guild
-        @client.guilds[@guild_id]
-      end
-    end
-
     #
     # Represents a `TYPING_START` event.
     #
@@ -430,7 +471,13 @@ module Discorb
       #   @macro client_cache
       #   @return [Discorb::Member, Discorb::User] The member or user that started typing.
 
+      #
+      # Initialize a new instance of the TypingStartEvent class.
       # @private
+      #
+      # @param [Discorb::Client] client The client that instantiated the object.
+      # @param [Hash] data The data of the event.
+      #
       def initialize(client, data)
         @client = client
         @data = data
@@ -438,7 +485,14 @@ module Discorb
         @guild_id = Snowflake.new(data[:guild_id]) if data.key?(:guild_id)
         @user_id = Snowflake.new(data[:user_id])
         @timestamp = Time.at(data[:timestamp])
-        @member = guild.members[@user_id] || Member.new(@client, @guild_id, @client.users[@user_id].instance_variable_get(:@data), data[:member]) if guild
+        if guild
+          @member = guild.members[@user_id] || Member.new(
+            @client,
+            @guild_id,
+            @client.users[@user_id].instance_variable_get(:@data),
+            data[:member]
+          )
+        end
       end
 
       def user
@@ -507,7 +561,13 @@ module Discorb
       #   @macro client_cache
       #   @return [Discorb::Guild] The guild where the webhook was updated.
 
+      #
+      # Initialize a new instance of the WebhooksUpdateEvent class.
       # @private
+      #
+      # @param [Discorb::Client] client The client that instantiated the object.
+      # @param [Hash] data The data of the event.
+      #
       def initialize(client, data)
         @client = client
         @data = data
@@ -531,115 +591,136 @@ module Discorb
       private
 
       def connect_gateway(reconnect)
-        if reconnect
-          @log.info "Reconnecting to gateway..."
-        else
-          @log.info "Connecting to gateway..."
-        end
         Async do
-          if @connection && !@connection.closed?
-            Async do
-              @connection.close
-            end
-          end
-          @http = HTTP.new(self)
-          _, gateway_response = @http.request(Route.new("/gateway", "//gateway", :get)).wait
-          gateway_url = gateway_response[:url]
-          gateway_version = if @intents.to_h[:message_content].nil?
-              warn "message_content intent not set, using gateway version 9. You should specify `message_content` intent for preventing unexpected changes in the future."
-              9
+          @mutex["gateway_#{shard_id}"] ||= Mutex.new
+          @mutex["gateway_#{shard_id}"].synchronize do
+            if reconnect
+              logger.info "Reconnecting to gateway..."
             else
-              10
+              logger.info "Connecting to gateway..."
             end
-          endpoint = Async::HTTP::Endpoint.parse("#{gateway_url}?v=#{gateway_version}&encoding=json&compress=zlib-stream",
-                                                 alpn_protocols: Async::HTTP::Protocol::HTTP11.names)
-          begin
-            @connection = Async::WebSocket::Client.connect(endpoint, headers: [["User-Agent", Discorb::USER_AGENT]], handler: RawConnection)
-            @zlib_stream = Zlib::Inflate.new(Zlib::MAX_WBITS)
-            buffer = +""
+
+            @http = HTTP.new(self)
+            _, gateway_response = @http.request(Route.new("/gateway", "//gateway", :get)).wait
+            gateway_url = gateway_response[:url]
+            gateway_version = if @intents.to_h[:message_content].nil?
+                warn "message_content intent not set, using gateway version 9. " \
+                     "You should specify `message_content` intent for preventing unexpected changes in the future."
+                9
+              else
+                10
+              end
+            endpoint = Async::HTTP::Endpoint.parse(
+              "#{gateway_url}?v=#{gateway_version}&encoding=json&compress=zlib-stream&_=#{Time.now.to_i}",
+              alpn_protocols: Async::HTTP::Protocol::HTTP11.names,
+            )
             begin
-              while (message = @connection.read)
-                buffer << message
-                if message.end_with?((+"\x00\x00\xff\xff").force_encoding("ASCII-8BIT"))
-                  begin
-                    data = @zlib_stream.inflate(buffer)
-                    buffer = +""
-                    message = JSON.parse(data, symbolize_names: true)
-                  rescue JSON::ParserError
-                    buffer = +""
-                    @log.error "Received invalid JSON from gateway."
-                    @log.debug "#{data}"
-                  else
-                    handle_gateway(message, reconnect)
+              self.connection = Async::WebSocket::Client.connect(
+                endpoint,
+                headers: [["User-Agent", Discorb::USER_AGENT]],
+                handler: RawConnection,
+              )
+              zlib_stream = Zlib::Inflate.new(Zlib::MAX_WBITS)
+              buffer = +""
+              begin
+                while (message = connection.read)
+                  buffer << message
+                  if message.end_with?((+"\x00\x00\xff\xff").force_encoding("ASCII-8BIT"))
+                    begin
+                      data = zlib_stream.inflate(buffer)
+                      buffer = +""
+                      message = JSON.parse(data, symbolize_names: true)
+                    rescue JSON::ParserError
+                      buffer = +""
+                      logger.error "Received invalid JSON from gateway."
+                      logger.debug "#{data}"
+                    else
+                      handle_gateway(message, reconnect)
+                    end
                   end
                 end
+              rescue Async::Wrapper::Cancelled,
+                     OpenSSL::SSL::SSLError,
+                     Async::Wrapper::WaitError,
+                     EOFError,
+                     Errno::EPIPE,
+                     Errno::ECONNRESET,
+                     IOError => e
+                next if @status == :closed
+
+                logger.error "Gateway connection closed accidentally: #{e.class}: #{e.message}"
+                connection.force_close
+                connect_gateway(true)
+                next
               end
-            rescue Async::Wrapper::Cancelled,
-                   OpenSSL::SSL::SSLError,
-                   Async::Wrapper::WaitError,
-                   EOFError,
-                   Errno::EPIPE,
-                   Errno::ECONNRESET,
-                   IOError => e
-              @log.error "Gateway connection closed accidentally: #{e.class}: #{e.message}"
-              @connection.force_close
-              connect_gateway(true)
-            else # should never happen
-              connect_gateway(true)
-            end
-          rescue Protocol::WebSocket::ClosedError => e
-            @tasks.map(&:stop)
-            case e.code
-            when 4004
-              raise ClientError.new("Authentication failed"), cause: nil
-            when 4009
-              @log.info "Session timed out, reconnecting."
-              connect_gateway(true)
-            when 4014
-              raise ClientError.new("Disallowed intents were specified"), cause: nil
-            when 4002, 4003, 4005, 4007
-              raise ClientError.new(<<~ERROR), cause: e
-                                                 Disconnected from gateway, probably due to library issues.
-                                                 #{e.message}
-
-                                                 Please report this to the library issue tracker.
-                                                 https://github.com/discorb-lib/discorb/issues
-                                               ERROR
-            when 1001
-              @log.info "Gateway closed with code 1001, reconnecting."
-              connect_gateway(true)
-            else
-              @log.error "Discord WebSocket closed with code #{e.code}."
-              @log.debug "#{e.message}"
+            rescue Protocol::WebSocket::ClosedError => e
+              @tasks.map(&:stop)
+              case e.code
+              when 4004
+                raise ClientError.new("Authentication failed"), cause: nil
+              when 4009
+                logger.info "Session timed out, reconnecting."
+                connection.force_close
+                connect_gateway(true)
+                next
+              when 4014
+                raise ClientError.new("Disallowed intents were specified"), cause: nil
+              when 4001, 4002, 4003, 4005, 4007
+                raise ClientError.new(<<~ERROR), cause: e
+                                                   Disconnected from gateway, probably due to library issues.
+                                                   #{e.message}
+
+                                                   Please report this to the library issue tracker.
+                                                   https://github.com/discorb-lib/discorb/issues
+                                                 ERROR
+              when 1001
+                logger.info "Gateway closed with code 1001, reconnecting."
+                connection.force_close
+                connect_gateway(true)
+                next
+              else
+                logger.error "Discord WebSocket closed with code #{e.code}."
+                logger.debug "#{e.message}"
+                connection.force_close
+                connect_gateway(false)
+                next
+              end
+            rescue StandardError => e
+              logger.error "Discord WebSocket error: #{e.full_message}"
+              connection.force_close
               connect_gateway(false)
+              next
             end
-          rescue StandardError => e
-            @log.error "Discord WebSocket error: #{e.full_message}"
-            @connection.force_close
-            connect_gateway(false)
           end
         end
       end
 
       def send_gateway(opcode, **value)
-        @connection.write({ op: opcode, d: value }.to_json)
-        @connection.flush
-        @log.debug "Sent message #{{ op: opcode, d: value }.to_json.gsub(@token, "[Token]")}"
+        if @shards.any? && shard.nil?
+          @shards.map(&:connection)
+        else
+          [connection]
+        end.each do |con|
+          con.write({ op: opcode, d: value }.to_json)
+          con.flush
+        end
+        logger.debug "Sent message to fd #{connection.io.fileno}: #{{ op: opcode, d: value }.to_json.gsub(@token,
+                                                                                                          "[Token]")}"
       end
 
       def handle_gateway(payload, reconnect)
         Async do |_task|
           data = payload[:d]
           @last_s = payload[:s] if payload[:s]
-          @log.debug "Received message with opcode #{payload[:op]} from gateway:"
-          @log.debug "#{payload.to_json.gsub(@token, "[Token]")}"
+          logger.debug "Received message with opcode #{payload[:op]} from gateway."
+          logger.debug "#{payload.to_json.gsub(@token, "[Token]")}"
           case payload[:op]
           when 10
             @heartbeat_interval = data[:heartbeat_interval]
             if reconnect
               payload = {
                 token: @token,
-                session_id: @session_id,
+                session_id: session_id,
                 seq: @last_s,
               }
               send_gateway(6, **payload)
@@ -650,27 +731,29 @@ module Discorb
                 compress: false,
                 properties: { "$os" => RUBY_PLATFORM, "$browser" => "discorb", "$device" => "discorb" },
               }
+              payload[:shard] = [shard_id, @shard_count] if shard_id
               payload[:presence] = @identify_presence if @identify_presence
               send_gateway(2, **payload)
             end
           when 7
-            @log.info "Received opcode 7, stopping tasks"
+            logger.info "Received opcode 7, stopping tasks"
             @tasks.map(&:stop)
           when 9
-            @log.warn "Received opcode 9, closed connection"
+            logger.warn "Received opcode 9, closed connection"
             @tasks.map(&:stop)
             if data
-              @log.info "Connection is resumable, reconnecting"
-              @connection.close
+              logger.info "Connection is resumable, reconnecting"
+              connection.force_close
               connect_gateway(true)
             else
-              @log.info "Connection is not resumable, reconnecting with opcode 2"
-              @connection.close
+              logger.info "Connection is not resumable, reconnecting with opcode 2"
+              connection.force_close
+
               sleep(2)
               connect_gateway(false)
             end
           when 11
-            @log.debug "Received opcode 11"
+            logger.debug "Received opcode 11"
             @ping = Time.now.to_f - @heartbeat_before
           when 0
             handle_event(payload[:t], data)
@@ -683,12 +766,12 @@ module Discorb
           interval = @heartbeat_interval
           sleep((interval / 1000.0 - 1) * rand)
           loop do
-            unless @connection.closed?
+            unless connection.closed?
               @heartbeat_before = Time.now.to_f
-              @connection.write({ op: 1, d: @last_s }.to_json)
-              @connection.flush
-              @log.debug "Sent opcode 1."
-              @log.debug "Waiting for heartbeat."
+              connection.write({ op: 1, d: @last_s }.to_json)
+              connection.flush
+              logger.debug "Sent opcode 1."
+              logger.debug "Waiting for heartbeat."
             end
             sleep(interval / 1000.0 - 1)
           end
@@ -696,29 +779,34 @@ module Discorb
       end
 
       def handle_event(event_name, data)
-        return @log.debug "Client isn't ready; event #{event_name} wasn't handled" if @wait_until_ready && !@ready && !%w[READY GUILD_CREATE].include?(event_name)
+        return logger.debug "Client isn't ready; event #{event_name} wasn't handled" if @wait_until_ready &&
+                                                                                        !@ready &&
+                                                                                        !%w[
+                                                                                          READY GUILD_CREATE
+                                                                                        ].include?(event_name)
 
         dispatch(:event_receive, event_name, data)
-        @log.debug "Handling event #{event_name}"
+        logger.debug "Handling event #{event_name}"
         case event_name
         when "READY"
           @api_version = data[:v]
-          @session_id = data[:session_id]
+          self.session_id = data[:session_id]
           @user = ClientUser.new(self, data[:user])
           @uncached_guilds = data[:guilds].map { |g| g[:id] }
           ready if (@uncached_guilds == []) || !@intents.guilds
           dispatch(:ready)
+
           @tasks << handle_heartbeat
         when "GUILD_CREATE"
           if @uncached_guilds.include?(data[:id])
             Guild.new(self, data, true)
             @uncached_guilds.delete(data[:id])
             if @uncached_guilds == []
-              @log.debug "All guilds cached"
+              logger.debug "All guilds cached"
               ready
             end
           elsif @guilds.has?(data[:id])
-            @guilds[data[:id]].send(:_set_data, data)
+            @guilds[data[:id]].send(:_set_data, data, true)
             dispatch(:guild_available, guild)
           else
             guild = Guild.new(self, data, true)
@@ -735,51 +823,53 @@ module Discorb
             current.send(:_set_data, data, false)
             dispatch(:guild_update, before, current)
           else
-            @log.warn "Unknown guild id #{data[:id]}, ignoring"
+            logger.warn "Unknown guild id #{data[:id]}, ignoring"
           end
         when "GUILD_DELETE"
-          return @log.warn "Unknown guild id #{data[:id]}, ignoring" unless (guild = @guilds.delete(data[:id]))
+          return logger.warn "Unknown guild id #{data[:id]}, ignoring" unless (guild = @guilds.delete(data[:id]))
 
           dispatch(:guild_delete, guild)
-          if guild.has?(:unavailable)
+          if data[:unavailable]
             dispatch(:guild_destroy, guild)
           else
             dispatch(:guild_leave, guild)
           end
         when "GUILD_ROLE_CREATE"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
 
           nr = Role.new(@client, guild, data[:role])
           guild.roles[data[:role][:id]] = nr
           dispatch(:role_create, nr)
         when "GUILD_ROLE_UPDATE"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-          return @log.warn "Unknown role id #{data[:role][:id]}, ignoring" unless guild.roles.has?(data[:role][:id])
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return logger.warn "Unknown role id #{data[:role][:id]}, ignoring" unless guild.roles.has?(data[:role][:id])
 
           current = guild.roles[data[:role][:id]]
           before = Role.new(@client, guild, current.instance_variable_get(:@data).update({ no_cache: true }))
           current.send(:_set_data, data[:role])
           dispatch(:role_update, before, current)
         when "GUILD_ROLE_DELETE"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-          return @log.warn "Unknown role id #{data[:role_id]}, ignoring" unless (role = guild.roles.delete(data[:role_id]))
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          unless (role = guild.roles.delete(data[:role_id]))
+            return logger.warn "Unknown role id #{data[:role_id]}, ignoring"
+          end
 
           dispatch(:role_delete, role)
         when "CHANNEL_CREATE"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
 
           nc = Channel.make_channel(self, data)
           guild.channels[data[:id]] = nc
 
           dispatch(:channel_create, nc)
         when "CHANNEL_UPDATE"
-          return @log.warn "Unknown channel id #{data[:id]}, ignoring" unless (current = @channels[data[:id]])
+          return logger.warn "Unknown channel id #{data[:id]}, ignoring" unless (current = @channels[data[:id]])
 
           before = Channel.make_channel(self, current.instance_variable_get(:@data), no_cache: true)
           current.send(:_set_data, data)
           dispatch(:channel_update, before, current)
         when "CHANNEL_DELETE"
-          return @log.warn "Unknown channel id #{data[:id]}, ignoring" unless (channel = @channels.delete(data[:id]))
+          return logger.warn "Unknown channel id #{data[:id]}, ignoring" unless (channel = @channels.delete(data[:id]))
 
           @guilds[data[:guild_id]]&.channels&.delete(data[:id])
           dispatch(:channel_delete, channel)
@@ -795,27 +885,29 @@ module Discorb
             dispatch(:thread_new, thread)
           end
         when "THREAD_UPDATE"
-          return @log.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels[data[:id]])
+          return logger.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels[data[:id]])
 
           before = Channel.make_channel(self, thread.instance_variable_get(:@data), no_cache: true)
           thread.send(:_set_data, data)
           dispatch(:thread_update, before, thread)
         when "THREAD_DELETE"
-          return @log.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels.delete(data[:id]))
+          return logger.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels.delete(data[:id]))
 
           @guilds[data[:guild_id]]&.channels&.delete(data[:id])
           dispatch(:thread_delete, thread)
         when "THREAD_LIST_SYNC"
           data[:threads].each do |raw_thread|
-            thread = Channel.make_channel(self, raw_thread.merge({ member: raw_thread[:members].find { |m| m[:id] == raw_thread[:id] } }))
+            thread = Channel.make_channel(self, raw_thread.merge({ member: raw_thread[:members].find do |m|
+              m[:id] == raw_thread[:id]
+            end }))
             @channels[thread.id] = thread
           end
         when "THREAD_MEMBER_UPDATE"
-          return @log.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels[data[:id]])
+          return logger.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels[data[:id]])
 
           if (member = thread.members[data[:id]])
             old = ThreadChannel::Member.new(self, member.instance_variable_get(:@data))
-            member._set_data(data)
+            member.send(:_set_data, data)
           else
             old = nil
             member = ThreadChannel::Member.new(self, data)
@@ -823,7 +915,7 @@ module Discorb
           end
           dispatch(:thread_member_update, thread, old, member)
         when "THREAD_MEMBERS_UPDATE"
-          return @log.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels[data[:id]])
+          return logger.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels[data[:id]])
 
           thread.instance_variable_set(:@member_count, data[:member_count])
           members = []
@@ -841,37 +933,49 @@ module Discorb
           instance = StageInstance.new(self, data)
           dispatch(:stage_instance_create, instance)
         when "STAGE_INSTANCE_UPDATE"
-          return @log.warn "Unknown channel id #{data[:channel_id]} , ignoring" unless (channel = @channels[data[:channel_id]])
-          return @log.warn "Unknown stage instance id #{data[:id]}, ignoring" unless (instance = channel.stage_instances[data[:id]])
+          unless (channel = @channels[data[:channel_id]])
+            return logger.warn "Unknown channel id #{data[:channel_id]} , ignoring"
+          end
+          unless (instance = channel.stage_instances[data[:id]])
+            return logger.warn "Unknown stage instance id #{data[:id]}, ignoring"
+          end
 
           old = StageInstance.new(self, instance.instance_variable_get(:@data), no_cache: true)
           current.send(:_set_data, data)
           dispatch(:stage_instance_update, old, current)
         when "STAGE_INSTANCE_DELETE"
-          return @log.warn "Unknown channel id #{data[:channel_id]} , ignoring" unless (channel = @channels[data[:channel_id]])
-          return @log.warn "Unknown stage instance id #{data[:id]}, ignoring" unless (instance = channel.stage_instances.delete(data[:id]))
+          unless (channel = @channels[data[:channel_id]])
+            return logger.warn "Unknown channel id #{data[:channel_id]} , ignoring"
+          end
+          unless (instance = channel.stage_instances.delete(data[:id]))
+            return logger.warn "Unknown stage instance id #{data[:id]}, ignoring"
+          end
 
           dispatch(:stage_instance_delete, instance)
         when "GUILD_MEMBER_ADD"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
 
           nm = Member.new(self, data[:guild_id], data[:user].update({ no_cache: true }), data)
           guild.members[nm.id] = nm
           dispatch(:member_add, nm)
         when "GUILD_MEMBER_UPDATE"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-          return @log.warn "Unknown member id #{data[:user][:id]}, ignoring" unless (nm = guild.members[data[:user][:id]])
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          unless (nm = guild.members[data[:user][:id]])
+            return logger.warn "Unknown member id #{data[:user][:id]}, ignoring"
+          end
 
           old = Member.new(self, data[:guild_id], data[:user], data.update({ no_cache: true }))
           nm.send(:_set_data, data[:user], data)
           dispatch(:member_update, old, nm)
         when "GUILD_MEMBER_REMOVE"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-          return @log.warn "Unknown member id #{data[:user][:id]}, ignoring" unless (member = guild.members.delete(data[:user][:id]))
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          unless (member = guild.members.delete(data[:user][:id]))
+            return logger.warn "Unknown member id #{data[:user][:id]}, ignoring"
+          end
 
           dispatch(:member_remove, member)
         when "GUILD_BAN_ADD"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
 
           user = if @users.has? data[:user][:id]
               @users[data[:user][:id]]
@@ -881,7 +985,7 @@ module Discorb
 
           dispatch(:guild_ban_add, guild, user)
         when "GUILD_BAN_REMOVE"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
 
           user = if @users.has? data[:user][:id]
               @users[data[:user][:id]]
@@ -891,7 +995,7 @@ module Discorb
 
           dispatch(:guild_ban_remove, guild, user)
         when "GUILD_EMOJIS_UPDATE"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
 
           before_emojis = guild.emojis.values.map(&:id).to_set
           data[:emojis].each do |emoji|
@@ -902,17 +1006,16 @@ module Discorb
             guild.emojis.delete(emoji)
           end
         when "GUILD_INTEGRATIONS_UPDATE"
-          # dispatch(:guild_integrations_update, GuildIntegrationsUpdateEvent.new(self, data))
-          # Currently not implemented
+          dispatch(:guild_integrations_update, @guilds[data[:guild_id]])
         when "INTEGRATION_CREATE"
           dispatch(:integration_create, Integration.new(self, data, data[:guild_id]))
         when "INTEGRATION_UPDATE"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
 
           integration = Integration.new(self, data, data[:guild_id])
           dispatch(:integration_update, integration)
         when "INTEGRATION_DELETE"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
 
           dispatch(:integration_delete, IntegrationDeleteEvent.new(self, data))
         when "WEBHOOKS_UPDATE"
@@ -922,7 +1025,7 @@ module Discorb
         when "INVITE_DELETE"
           dispatch(:invite_delete, InviteDeleteEvent.new(self, data))
         when "VOICE_STATE_UPDATE"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
 
           current = guild.voice_states[data[:user_id]]
           if current.nil?
@@ -1019,7 +1122,7 @@ module Discorb
             end
           end
         when "PRESENCE_UPDATE"
-          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return logger.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
 
           guild.presences[data[:user][:id]] = Presence.new(self, data)
         when "MESSAGE_UPDATE"
@@ -1045,7 +1148,8 @@ module Discorb
         when "MESSAGE_DELETE"
           message.instance_variable_set(:@deleted, true) if (message = @messages[data[:id]])
 
-          dispatch(:message_delete_id, Snowflake.new(data[:id]), channels[data[:channel_id]], data[:guild_id] && guilds[data[:guild_id]])
+          dispatch(:message_delete_id, Snowflake.new(data[:id]), channels[data[:channel_id]],
+                   data[:guild_id] && guilds[data[:guild_id]])
           dispatch(:message_delete, message, channels[data[:channel_id]], data[:guild_id] && guilds[data[:guild_id]])
         when "MESSAGE_DELETE_BULK"
           messages = []
@@ -1092,10 +1196,12 @@ module Discorb
           dispatch(:reaction_remove_all, ReactionRemoveAllEvent.new(self, data))
         when "MESSAGE_REACTION_REMOVE_EMOJI"
           if (target_message = @messages[data[:message_id]]) &&
-             (target_reaction = target_message.reactions.find { |r| data[:emoji][:id].nil? ? r.name == data[:emoji][:name] : r.id == data[:emoji][:id] })
+             (target_reaction = target_message.reactions.find do |r|
+               data[:emoji][:id].nil? ? r.name == data[:emoji][:name] : r.id == data[:emoji][:id]
+             end)
             target_message.reactions.delete(target_reaction)
           end
-          dispatch(:reaction_remove_emoji, ReactionRemoveEmojiEvent.new(data))
+          dispatch(:reaction_remove_emoji, ReactionRemoveEmojiEvent.new(self, data))
         when "TYPING_START"
           dispatch(:typing_start, TypingStartEvent.new(self, data))
         when "INTERACTION_CREATE"
@@ -1104,17 +1210,23 @@ module Discorb
 
           dispatch(interaction.class.event_name, interaction)
         when "RESUMED"
-          @log.info("Successfully resumed connection")
+          logger.info("Successfully resumed connection")
           @tasks << handle_heartbeat
-          dispatch(:resumed)
+          if shard
+            dispatch(:shard_resumed, shard)
+          else
+            dispatch(:resumed)
+          end
         when "GUILD_SCHEDULED_EVENT_CREATE"
-          @log.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
+          logger.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
           event = ScheduledEvent.new(self, data)
           guild.scheduled_events[data[:id]] = event
           dispatch(:scheduled_event_create, event)
         when "GUILD_SCHEDULED_EVENT_UPDATE"
-          @log.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
-          @log.warn("Unknown scheduled event id #{data[:id]}, ignoring") unless (event = guild.scheduled_events[data[:id]])
+          logger.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
+          unless (event = guild.scheduled_events[data[:id]])
+            logger.warn("Unknown scheduled event id #{data[:id]}, ignoring")
+          end
           old = event.dup
           event.send(:_set_data, data)
           dispatch(:scheduled_event_update, old, event)
@@ -1129,22 +1241,24 @@ module Discorb
             end
           end
         when "GUILD_SCHEDULED_EVENT_DELETE"
-          @log.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
-          @log.warn("Unknown scheduled event id #{data[:id]}, ignoring") unless (event = guild.scheduled_events[data[:id]])
+          logger.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
+          unless (event = guild.scheduled_events[data[:id]])
+            logger.warn("Unknown scheduled event id #{data[:id]}, ignoring")
+          end
           guild.scheduled_events.remove(data[:id])
           dispatch(:scheduled_event_delete, event)
           dispatch(:scheduled_event_cancel, event)
         when "GUILD_SCHEDULED_EVENT_USER_ADD"
-          @log.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
+          logger.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
           dispatch(:scheduled_event_user_add, ScheduledEventUserEvent.new(self, data))
         when "GUILD_SCHEDULED_EVENT_USER_REMOVE"
-          @log.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
+          logger.warn("Unknown guild id #{data[:guild_id]}, ignoring") unless (guild = @guilds[data[:guild_id]])
           dispatch(:scheduled_event_user_remove, ScheduledEventUserEvent.new(self, data))
         else
           if respond_to?("event_" + event_name.downcase)
             __send__("event_" + event_name.downcase, data)
           else
-            @log.debug "Unhandled event: #{event_name}\n#{data.inspect}"
+            logger.debug "Unhandled event: #{event_name}\n#{data.inspect}"
           end
         end
       end
@@ -1152,7 +1266,7 @@ module Discorb
       def ready
         Async do
           if @fetch_member
-            @log.debug "Fetching members"
+            logger.debug "Fetching members"
             barrier = Async::Barrier.new
 
             @guilds.each do |guild|
@@ -1163,8 +1277,25 @@ module Discorb
             barrier.wait
           end
           @ready = true
-          dispatch(:standby)
-          @log.info("Client is ready!")
+
+          if self.shard
+            logger.info("Shard #{shard_id} is ready!")
+            self.shard&.tap do |shard|
+              if shard.next_shard
+                dispatch(:shard_standby, shard)
+                shard.next_shard.tap do |next_shard|
+                  logger.debug("Starting shard #{next_shard.id}")
+                  next_shard.start
+                end
+              else
+                logger.info("All shards are ready!")
+                dispatch(:standby)
+              end
+            end
+          else
+            logger.info("Client is ready!")
+            dispatch(:standby)
+          end
         end
       end
     end
@@ -1179,6 +1310,10 @@ module Discorb
         @closed = false
       end
 
+      def inspect
+        "<#{self.class.name} #{io.fileno}>"
+      end
+
       def closed?
         @closed
       end
@@ -1191,10 +1326,18 @@ module Discorb
       end
 
       def force_close
-        @framer.instance_variable_get(:@stream).instance_variable_get(:@io).instance_variable_get(:@io).instance_variable_get(:@io).close
+        io.close
         @closed = true
       end
 
+      def io
+        @framer
+          .instance_variable_get(:@stream)
+          .instance_variable_get(:@io)
+          .instance_variable_get(:@io)
+          .instance_variable_get(:@io)
+      end
+
       def parse(buffer)
         # noop
         buffer.to_s