discorb 0.15.1 → 0.16.0

data/lib/discorb/gateway.rb

@@ -581,115 +581,129 @@ 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)
@@ -700,27 +714,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)
@@ -733,12 +749,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
@@ -746,25 +762,26 @@ 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])
@@ -785,10 +802,10 @@ 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 data[:unavailable]
@@ -797,39 +814,39 @@ module Discorb
             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]])
+          return logger.warn "Unknown role id #{data[:role_id]}, ignoring" unless (role = guild.roles.delete(data[:role_id]))
 
           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)
@@ -845,13 +862,13 @@ 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)
@@ -861,7 +878,7 @@ module Discorb
             @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))
@@ -873,7 +890,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 = []
@@ -891,37 +908,37 @@ 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]])
+          return logger.warn "Unknown channel id #{data[:channel_id]} , ignoring" unless (channel = @channels[data[:channel_id]])
+          return logger.warn "Unknown stage instance id #{data[:id]}, ignoring" unless (instance = channel.stage_instances[data[:id]])
 
           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]))
+          return logger.warn "Unknown channel id #{data[:channel_id]} , ignoring" unless (channel = @channels[data[:channel_id]])
+          return logger.warn "Unknown stage instance id #{data[:id]}, ignoring" unless (instance = channel.stage_instances.delete(data[:id]))
 
           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]])
+          return logger.warn "Unknown member id #{data[:user][:id]}, ignoring" unless (nm = guild.members[data[:user][:id]])
 
           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]])
+          return logger.warn "Unknown member id #{data[:user][:id]}, ignoring" unless (member = guild.members.delete(data[:user][:id]))
 
           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]]
@@ -931,7 +948,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]]
@@ -941,7 +958,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|
@@ -956,12 +973,12 @@ module Discorb
         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"
@@ -971,7 +988,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?
@@ -1068,7 +1085,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"
@@ -1153,17 +1170,21 @@ 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]])
+          logger.warn("Unknown scheduled event id #{data[:id]}, ignoring") unless (event = guild.scheduled_events[data[:id]])
           old = event.dup
           event.send(:_set_data, data)
           dispatch(:scheduled_event_update, old, event)
@@ -1178,22 +1199,22 @@ 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]])
+          logger.warn("Unknown scheduled event id #{data[:id]}, ignoring") unless (event = guild.scheduled_events[data[:id]])
           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
@@ -1201,7 +1222,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|
@@ -1212,8 +1233,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

data/lib/discorb/http.rb

@@ -107,7 +107,7 @@ module Discorb
     def handle_response(resp, data, path, body, headers, audit_log_reason, kwargs)
       case resp.code
       when "429"
-        @client.log.info("Rate limit exceeded for #{path.method} #{path.url}, waiting #{data[:retry_after]} seconds")
+        @client.logger.info("Rate limit exceeded for #{path.method} #{path.url}, waiting #{data[:retry_after]} seconds")
         sleep(data[:retry_after])
         request(path, body, headers: headers, audit_log_reason: audit_log_reason, **kwargs).wait
       when "400"
@@ -128,7 +128,7 @@ module Discorb
           { "User-Agent" => USER_AGENT, "authorization" => "Bot #{@client.token}" }
         else
           { "User-Agent" => USER_AGENT, "authorization" => "Bot #{@client.token}",
-            "content-type" => "application/json", }
+            "content-type" => "application/json" }
         end
       ret.merge!(headers) if !headers.nil? && headers.length.positive?
       ret["X-Audit-Log-Reason"] = audit_log_reason unless audit_log_reason.nil?

data/lib/discorb/interaction/autocomplete.rb

@@ -15,7 +15,7 @@ module Discorb
         name, options = Discorb::CommandInteraction::SlashCommand.get_command_data(data)
 
         unless (command = @client.bottom_commands.find { |c| c.to_s == name && c.type_raw == 1 })
-          @client.log.warn "Unknown command name #{name}, ignoring"
+          @client.logger.warn "Unknown command name #{name}, ignoring"
           next
         end
 
@@ -40,7 +40,7 @@ module Discorb
         },
       }).wait
     rescue Discorb::NotFoundError
-      @client.log.warn "Failed to send auto complete result, This may be caused by the suggestion is taking too long (over 3 seconds) to respond", fallback: $stderr
+      @client.logger.warn "Failed to send auto complete result, This may be caused by the suggestion is taking too long (over 3 seconds) to respond", fallback: $stderr
     end
 
     class << self

data/lib/discorb/interaction/command.rb

@@ -24,7 +24,7 @@ module Discorb
         name, options = SlashCommand.get_command_data(data)
 
         unless (command = @client.bottom_commands.find { |c| c.to_s == name && c.type_raw == 1 })
-          @client.log.warn "Unknown command name #{name}, ignoring"
+          @client.logger.warn "Unknown command name #{name}, ignoring"
           return
         end
 
@@ -180,7 +180,7 @@ module Discorb
             return interaction
           end
         end
-        client.log.warn("Unknown command type #{data[:type]}, initialized CommandInteraction")
+        client.logger.warn("Unknown command type #{data[:type]}, initialized CommandInteraction")
         CommandInteraction.new(client, data)
       end
 

data/lib/discorb/interaction/components.rb

@@ -43,7 +43,7 @@ module Discorb
         nested_classes.each do |klass|
           return klass.new(client, data) if !klass.component_type.nil? && klass.component_type == data[:data][:component_type]
         end
-        client.log.warn("Unknown component type #{data[:component_type]}, initialized Interaction")
+        client.logger.warn("Unknown component type #{data[:component_type]}, initialized Interaction")
         MessageComponentInteraction.new(client, data)
       end