crates/gateway/src/discord/gateway.rs

@@ -6,7 +6,7 @@ use std::sync::Arc;
 use tokio::sync::mpsc::Sender;
 use tracing::{error, info, warn};
 use twilight_gateway::{
-    create_iterator, CloseFrame, ConfigBuilder, Event, EventTypeFlags, Message, Shard, ShardId,
+    create_iterator, ConfigBuilder, Event, EventTypeFlags, Message, Shard, ShardId,
 };
 use twilight_model::gateway::{
     payload::outgoing::update_presence::UpdatePresencePayload,
@@ -116,11 +116,7 @@ pub async fn runner(
         let raw_event = match item {
             Ok(evt) => match evt {
                 Message::Close(frame) => {
-                    let mut state_event = ShardStateEvent::Closed;
                     let close_code = if let Some(close) = frame {
-                        if close == CloseFrame::RESUME {
-                            state_event = ShardStateEvent::Reconnect;
-                        }
                         close.code.to_string()
                     } else {
                         "unknown".to_string()
@@ -135,7 +131,9 @@ pub async fn runner(
                     )
                     .increment(1);
 
-                    if let Err(error) = tx_state.try_send((shard.id(), state_event, None, None)) {
+                    if let Err(error) =
+                        tx_state.try_send((shard.id(), ShardStateEvent::Closed, None, None))
+                    {
                         error!("failed to update shard state for socket closure: {error}");
                     }
 

crates/gateway/src/discord/shard_state.rs

@@ -86,7 +86,7 @@ impl ShardStateManager {
         Ok(())
     }
 
-    pub async fn socket_closed(&self, shard_id: u32, reconnect: bool) -> anyhow::Result<()> {
+    pub async fn socket_closed(&self, shard_id: u32) -> anyhow::Result<()> {
         gauge!("pluralkit_gateway_shard_up").decrement(1);
 
         let mut info = self
@@ -97,7 +97,6 @@ impl ShardStateManager {
         info.shard_id = shard_id as i32;
         info.cluster_id = Some(cluster_config().node_id as i32);
         info.up = false;
-        info.last_reconnect = chrono::offset::Utc::now().timestamp() as i32;
         info.disconnection_count += 1;
 
         self.save_shard(shard_id, info).await?;

crates/gateway/src/main.rs

@@ -109,16 +109,8 @@ async fn main() -> anyhow::Result<()> {
                         };
                     }
                     ShardStateEvent::Closed => {
-                        if let Err(error) =
-                            shard_state.socket_closed(shard_id.number(), false).await
-                        {
-                            error!("failed to update shard state for closed: {error}")
-                        };
-                    }
-                    ShardStateEvent::Reconnect => {
-                        if let Err(error) = shard_state.socket_closed(shard_id.number(), true).await
-                        {
-                            error!("failed to update shard state for reconnect: {error}")
+                        if let Err(error) = shard_state.socket_closed(shard_id.number()).await {
+                            error!("failed to update shard state for heartbeat: {error}")
                         };
                     }
                     ShardStateEvent::Other => {
@@ -129,7 +121,7 @@ async fn main() -> anyhow::Result<()> {
                             )
                             .await
                         {
-                            error!("failed to update shard state for other evt: {error}")
+                            error!("failed to update shard state for heartbeat: {error}")
                         };
                     }
                 }

crates/libpk/src/state.rs

@@ -8,13 +8,11 @@ pub struct ShardState {
     /// unix timestamp
     pub last_heartbeat: i32,
     pub last_connection: i32,
-    pub last_reconnect: i32,
     pub cluster_id: Option<i32>,
 }
 
 pub enum ShardStateEvent {
     Closed,
     Heartbeat,
-    Reconnect,
     Other,
 }