do pull request as async

Author: anthony-nhs

packages/slackBotFunction/app/slack/slack_events.py

@@ -13,6 +13,7 @@
 from app.core.config import (
     BOT_MESSAGES,
     constants,
+    get_bot_token,
     get_logger,
 )
 from app.services.bedrock import query_bedrock
@@ -175,7 +176,7 @@ def process_async_slack_event(slack_event_data: Dict[str, Any]):
     """
     event = slack_event_data["event"]
     event_id = slack_event_data["event_id"]
-    token = slack_event_data["bot_token"]
+    token = get_bot_token()
 
     client = WebClient(token=token)
 

packages/slackBotFunction/app/slack/slack_handlers.py

@@ -316,7 +316,6 @@ def _common_message_handler(
 ):
     channel_id = event["channel"]
     user_id = event.get("user", "unknown")
-    bot_token = get_bot_token()
     if message_text.lower().startswith(constants.FEEDBACK_PREFIX):
         feedback_text = message_text.split(":", 1)[1].strip() if ":" in message_text else ""
         try:
@@ -349,9 +348,9 @@ def _common_message_handler(
     if message_text.lower().startswith(constants.PULL_REQUEST_PREFIX):
         try:
             pull_request_id, extracted_message = _extract_pull_request_id(message_text)
-            trigger_pull_request_processing(pull_request_id=pull_request_id, body=body)
+            trigger_pull_request_processing(pull_request_id=pull_request_id, event=event, event_id=event_id)
         except Exception as e:
             logger.error(f"Can not find pull request details: {e}", extra={"error": traceback.format_exc()})
         return
 
-    trigger_async_processing({"event": event, "event_id": event_id, "bot_token": bot_token})
+    trigger_async_processing(event=event, event_id=event_id)

packages/slackBotFunction/app/utils/handler_utils.py

@@ -40,7 +40,7 @@ def is_duplicate_event(event_id):
         return False
 
 
-def trigger_async_processing(event_data):
+def trigger_async_processing(event: Dict[str, Any], event_id: str):
     """
     Trigger asynchronous Lambda invocation to process Slack events
 
@@ -49,14 +49,16 @@ def trigger_async_processing(event_data):
     actual AI processing without blocking the initial Slack response.
     """
     # incase we fail to re-invoke the lambda we should log an error
+    lambda_client: LambdaClient = boto3.client("lambda")
     try:
-        lambda_client: LambdaClient = boto3.client("lambda")
+        logger.debug("Triggering async lambda processing")
+        lambda_payload = {"async_processing": True, "slack_event": {"event": event, "event_id": event_id}}
         lambda_client.invoke(
             FunctionName=os.environ["AWS_LAMBDA_FUNCTION_NAME"],
             InvocationType="Event",
-            Payload=json.dumps({"async_processing": True, "slack_event": event_data}),
+            Payload=json.dumps(lambda_payload),
         )
-        logger.info("Async processing triggered successfully")
+        logger.debug("Async processing triggered successfully")
     except Exception:
         logger.error("Failed to trigger async processing", extra={"error": traceback.format_exc()})
 
@@ -72,7 +74,7 @@ def respond_with_eyes(bot_token: str, event: Dict[str, Any]):
         logger.warning("Failed to respond with eyes", extra={"error": traceback.format_exc()})
 
 
-def trigger_pull_request_processing(pull_request_id: str, body: Dict[str, Any]):
+def trigger_pull_request_processing(pull_request_id: str, event: Dict[str, Any], event_id: str):
     cloudformation_client: CloudFormationClient = boto3.client("cloudformation")
     lambda_client: LambdaClient = boto3.client("lambda")
     try:
@@ -82,7 +84,7 @@ def trigger_pull_request_processing(pull_request_id: str, body: Dict[str, Any]):
 
         pull_request_lambda_arn = outputs.get("SlackBotLambdaArn")
         logger.debug("Triggering pull request lambda", extra={"lambda_arn": pull_request_lambda_arn})
-        lambda_payload = {"body": json.dumps(body)}
+        lambda_payload = {"async_processing": True, "slack_event": {"event": event, "event_id": event_id}}
         response = lambda_client.invoke(
             FunctionName=pull_request_lambda_arn, InvocationType="Event", Payload=json.dumps(lambda_payload)
         )

packages/slackBotFunction/tests/test_async_processing.py

@@ -8,7 +8,13 @@
 @patch("app.services.query_reformulator.reformulate_query")
 @patch("app.slack.slack_events.get_conversation_session")
 def test_process_async_slack_event_success(
-    mock_get_session, mock_reformulate_query, mock_query_bedrock, mock_get_state_information, mock_webclient, mock_env
+    mock_get_session: Mock,
+    mock_reformulate_query: Mock,
+    mock_query_bedrock: Mock,
+    mock_get_state_information: Mock,
+    mock_webclient: Mock,
+    mock_get_parameter: Mock,
+    mock_env: Mock,
 ):
     """Test successful async event processing"""
     # set up mocks
@@ -42,7 +48,7 @@ def test_process_async_slack_event_success(
 
 
 @patch("slack_sdk.WebClient")
-def test_process_async_slack_event_empty_query(mock_webclient, mock_env):
+def test_process_async_slack_event_empty_query(mock_webclient: Mock, mock_get_parameter: Mock, mock_env: Mock):
     """Test async event processing with empty query"""
     # set up mocks
     mock_client = Mock()
@@ -80,7 +86,13 @@ def test_process_async_slack_event_empty_query(mock_webclient, mock_env):
 @patch("app.services.query_reformulator.reformulate_query")
 @patch("app.slack.slack_events.get_conversation_session")
 def test_process_async_slack_event_error(
-    mock_get_session, mock_reformulate_query, mock_query_bedrock, mock_get_state_information, mock_webclient, mock_env
+    mock_get_session: Mock,
+    mock_reformulate_query: Mock,
+    mock_query_bedrock: Mock,
+    mock_get_state_information: Mock,
+    mock_webclient: Mock,
+    mock_get_parameter: Mock,
+    mock_env: Mock,
 ):
     """Test async event processing with error"""
     # set up mocks
@@ -117,7 +129,13 @@ def test_process_async_slack_event_error(
 @patch("app.services.query_reformulator.reformulate_query")
 @patch("app.slack.slack_events.get_conversation_session")
 def test_process_async_slack_event_with_thread_ts(
-    mock_get_session, mock_reformulate_query, mock_query_bedrock, mock_get_state_information, mock_webclient, mock_env
+    mock_get_session: Mock,
+    mock_reformulate_query: Mock,
+    mock_query_bedrock: Mock,
+    mock_get_state_information: Mock,
+    mock_webclient: Mock,
+    mock_get_parameter: Mock,
+    mock_env: Mock,
 ):
     """Test async event processing with existing thread_ts"""
     # set up mocks
@@ -162,7 +180,13 @@ def test_process_async_slack_event_with_thread_ts(
 @patch("app.services.query_reformulator.reformulate_query")
 @patch("app.slack.slack_events.get_conversation_session")
 def test_regex_text_processing(
-    mock_get_session, mock_reformulate_query, mock_query_bedrock, mock_get_state_information, mock_webclient, mock_env
+    mock_get_session: Mock,
+    mock_reformulate_query: Mock,
+    mock_query_bedrock: Mock,
+    mock_get_state_information: Mock,
+    mock_webclient: Mock,
+    mock_get_parameter: Mock,
+    mock_env: Mock,
 ):
     """Test regex text processing functionality within process_async_slack_event"""
     # set up mocks
@@ -199,12 +223,13 @@ def test_regex_text_processing(
 @patch("app.services.bedrock.query_bedrock")
 @patch("app.services.query_reformulator.reformulate_query")
 def test_process_async_slack_event_with_session_storage(
-    mock_reformulate_query,
-    mock_query_bedrock,
-    mock_store_state_information,
-    mock_get_state_information,
-    mock_webclient,
-    mock_env,
+    mock_reformulate_query: Mock,
+    mock_query_bedrock: Mock,
+    mock_store_state_information: Mock,
+    mock_get_state_information: Mock,
+    mock_webclient: Mock,
+    mock_get_parameter: Mock,
+    mock_env: Mock,
 ):
     """Test async event processing that stores a new session"""
     # set up mocks
@@ -242,7 +267,13 @@ def test_process_async_slack_event_with_session_storage(
 @patch("app.services.query_reformulator.reformulate_query")
 @patch("app.slack.slack_events.get_conversation_session")
 def test_process_async_slack_event_chat_update_error(
-    mock_get_session, mock_reformulate_query, mock_query_bedrock, mock_get_state_information, mock_webclient, mock_env
+    mock_get_session: Mock,
+    mock_reformulate_query: Mock,
+    mock_query_bedrock: Mock,
+    mock_get_state_information: Mock,
+    mock_webclient: Mock,
+    mock_get_parameter: Mock,
+    mock_env: Mock,
 ):
     """Test process_async_slack_event with chat_update error"""
     # set up mocks
@@ -277,7 +308,13 @@ def test_process_async_slack_event_chat_update_error(
 @patch("app.services.query_reformulator.reformulate_query")
 @patch("app.slack.slack_events.get_conversation_session")
 def test_process_async_slack_event_dm_context(
-    mock_get_session, mock_reformulate_query, mock_query_bedrock, mock_get_state_information, mock_webclient, mock_env
+    mock_get_session: Mock,
+    mock_reformulate_query: Mock,
+    mock_query_bedrock: Mock,
+    mock_get_state_information: Mock,
+    mock_webclient: Mock,
+    mock_get_parameter: Mock,
+    mock_env: Mock,
 ):
     """Test process_async_slack_event with DM context"""
     # set up mocks

packages/slackBotFunction/tests/test_slack_handlers.py

@@ -53,9 +53,7 @@ def decorator(func):
 
     # assertions
     mock_ack.assert_called_once()
-    mock_trigger_async_processing.assert_called_once_with(
-        {"event": mock_event, "event_id": "evt123", "bot_token": "test-token"}
-    )
+    mock_trigger_async_processing.assert_called_once_with(event=mock_event, event_id="evt123")
     mock_respond_with_eyes.assert_called_once()
 
 

packages/slackBotFunction/tests/test_state_management.py

@@ -73,7 +73,7 @@ def test_trigger_async_processing_error(mock_boto_client, mock_env):
 
     event_data = {"test": "data"}
     # Should not raise exception even if Lambda invoke fails
-    trigger_async_processing(event_data)
+    trigger_async_processing(event=event_data, event_id="evt123")
 
     mock_boto_client.assert_called_once_with("lambda")
     mock_lambda_client.invoke.assert_called_once()
@@ -93,7 +93,7 @@ def test_trigger_async_processing(
     from app.utils.handler_utils import trigger_async_processing
 
     event_data = {"test": "data"}
-    trigger_async_processing(event_data)
+    trigger_async_processing(event=event_data, event_id="evt123")
 
     mock_boto_client.assert_called_once_with("lambda")
     mock_lambda_client.invoke.assert_called_once()