diff --git a/crates/gateway/src/discord/gateway.rs b/crates/gateway/src/discord/gateway.rs
index cbc5f1a1..6aedca23 100644
--- a/crates/gateway/src/discord/gateway.rs
+++ b/crates/gateway/src/discord/gateway.rs
@@ -83,29 +83,38 @@ pub async fn runner(
     cache: Arc<DiscordCache>,
 ) {
     // let _span = info_span!("shard_runner", shard_id = shard.id().number()).entered();
+    let shard_id = shard.id().number();
+
     info!("waiting for events");
     while let Some(item) = shard.next().await {
         let raw_event = match item {
             Ok(evt) => match evt {
                 Message::Close(frame) => {
-                    info!(
-                        "shard {} closed: {}",
-                        shard.id().number(),
-                        if let Some(close) = frame {
-                            format!("{} ({})", close.code, close.reason)
-                        } else {
-                            "unknown".to_string()
-                        }
-                    );
-                    if let Err(error) = shard_state.socket_closed(shard.id().number()).await {
+                    let close_code = if let Some(close) = frame {
+                        close.code.to_string()
+                    } else {
+                        "unknown".to_string()
+                    };
+
+                    info!("shard {shard_id} closed: {close_code}");
+
+                    counter!(
+                        "pluralkit_gateway_shard_closed",
+                        "shard_id" => shard_id.to_string(),
+                        "close_code" => close_code,
+                    )
+                    .increment(1);
+
+                    if let Err(error) = shard_state.socket_closed(shard_id).await {
                         error!("failed to update shard state for socket closure: {error}");
                     }
+
                     continue;
                 }
                 Message::Text(text) => text,
             },
             Err(error) => {
-                tracing::warn!(?error, "error receiving event from shard {}", shard.id());
+                tracing::warn!(?error, "error receiving event from shard {shard_id}");
                 continue;
             }
         };
@@ -118,11 +127,7 @@ pub async fn runner(
                 continue;
             }
             Err(error) => {
-                error!(
-                    "shard {} failed to parse gateway event: {}",
-                    shard.id().number(),
-                    error
-                );
+                error!("shard {shard_id} failed to parse gateway event: {error}");
                 continue;
             }
         };
@@ -137,29 +142,24 @@ pub async fn runner(
         .increment(1);
         counter!(
             "pluralkit_gateway_events_shard",
-            "shard_id" => shard.id().number().to_string(),
+            "shard_id" => shard_id.to_string(),
         )
         .increment(1);
 
         // update shard state and discord cache
-        if let Err(error) = shard_state
-            .handle_event(shard.id().number(), event.clone())
-            .await
-        {
-            tracing::warn!(?error, "error updating redis state");
+        if let Err(error) = shard_state.handle_event(shard_id, event.clone()).await {
+            tracing::error!(?error, "error updating redis state");
         }
         // need to do heartbeat separately, to get the latency
         if let Event::GatewayHeartbeatAck = event
-            && let Err(error) = shard_state
-                .heartbeated(shard.id().number(), shard.latency())
-                .await
+            && let Err(error) = shard_state.heartbeated(shard_id, shard.latency()).await
         {
-            tracing::warn!(?error, "error updating redis state for latency");
+            tracing::error!(?error, "error updating redis state for latency");
         }
 
         if let Event::Ready(_) = event {
-            if !cache.2.read().await.contains(&shard.id().number()) {
-                cache.2.write().await.push(shard.id().number());
+            if !cache.2.read().await.contains(&shard_id) {
+                cache.2.write().await.push(shard_id);
             }
         }
         cache.0.update(&event);