fix(socket_mode): shut down current_session_runner in built-in close()

The built-in SocketModeClient starts three IntervalRunner daemon threads
in __init__ (current_session_runner, current_app_monitor, message_processor)
but close() only shut down two of them, leaking current_session_runner on
every closed instance. Long-lived processes that open and close many clients
accumulate one idle thread per closed instance (issue #1873).

The sync sibling websocket_client.close() already shuts its
current_session_runner down, and the async backends cancel all their futures.
The leak was built-in only.

Adding the shutdown alone is not enough: current_session_runner runs
run_until_completion, whose loop exits only when the connection state is
terminated. disconnect() does not set that flag, and shutdown() joins with no
timeout, so the join would hang on a connected client. close() now sets
current_session_state.terminated = True before disconnecting (mirroring
connect()'s handling of a retired session), letting the loop return so the
join completes. This is the CI hang the earlier #1874 attempt ran into.

Adds a regression test on the connected path (connect then close) asserting
all three runners are reaped; it hangs under pytest-timeout if terminated is
not set, so it guards both the leak and the deadlock.

Refs #1873. Supersedes #1874.

Co-Authored-By: Claude <svc-devxp-claude@slack-corp.com>

Author: WilliamBergamin

slack_sdk/socket_mode/builtin/client.py

@@ -221,10 +221,13 @@ def send_message(self, message: str) -> None:
                     )
                     raise e
 
-    def close(self):
+    def close(self) -> None:
         self.closed = True
         self.auto_reconnect_enabled = False
+        self.current_session_state.terminated = True
         self.disconnect()
+        if self.current_session_runner.is_alive():
+            self.current_session_runner.shutdown()
         if self.current_app_monitor.is_alive():
             self.current_app_monitor.shutdown()
         if self.message_processor.is_alive():

tests/slack_sdk/socket_mode/test_interactions_builtin.py

@@ -145,3 +145,28 @@ def test_send_message_while_disconnection(self):
             client.send_message("foo")
         finally:
             client.close()
+
+    def test_close_reaps_current_session_runner(self):
+        # Regression for #1873: close() must shut down every interval-runner thread it started,
+        # including current_session_runner, and must return (not hang) on the connected path.
+        client = SocketModeClient(
+            app_token="xapp-A111-222-xyz",
+            web_client=self.web_client,
+            auto_reconnect_enabled=False,
+            trace_enabled=True,
+        )
+        try:
+            client.wss_uri = "ws://0.0.0.0:3011/link"
+            client.connect()
+            self.assertTrue(client.is_connected())
+            time.sleep(1)  # let current_session_runner enter run_until_completion
+
+            client.close()
+
+            # The leaked thread from #1873 (RED -> GREEN driver):
+            self.assertFalse(client.current_session_runner.is_alive())
+            # Full-contract invariants: close() reaps all three runners:
+            self.assertFalse(client.current_app_monitor.is_alive())
+            self.assertFalse(client.message_processor.is_alive())
+        finally:
+            client.close()