Merge branch 'pull_request_conversation_1' into pull_request_conversation_2

Author: anthony-nhs

packages/slackBotFunction/app/core/config.py

@@ -11,6 +11,7 @@
 from typing import Tuple
 import boto3
 from aws_lambda_powertools import Logger
+from aws_lambda_powertools.logging import utils
 from aws_lambda_powertools.utilities.parameters import get_parameter
 from mypy_boto3_dynamodb.service_resource import Table
 
@@ -19,7 +20,9 @@
 
 @lru_cache()
 def get_logger() -> Logger:
-    return Logger(service="slackBotFunction")
+    powertools_logger = Logger(service="slackBotFunction")
+    utils.copy_config_to_registered_loggers(source_logger=powertools_logger, ignore_log_level=True)
+    return powertools_logger
 
 
 # set up logger as its used in other functions

packages/slackBotFunction/app/handler.py

@@ -11,10 +11,9 @@
 
 from app.core.config import get_logger
 from app.services.app import get_app
-from app.slack.slack_events import process_async_slack_event, process_pull_request_slack_event
+from app.slack.slack_events import process_pull_request_slack_event
 
 logger = get_logger()
-app = get_app()
 
 
 @logger.inject_lambda_context(log_event=True, clear_state=True)
@@ -27,18 +26,8 @@ def handler(event: dict, context: LambdaContext) -> dict:
     2. Lambda acknowledges immediately and triggers async self-invocation
     3. Async invocation processes Bedrock query and responds to Slack
     """
-
-    # handle async processing requests
-    if event.get("async_processing"):
-        slack_event_data = event.get("slack_event")
-        if not slack_event_data:
-            logger.error("Async processing requested but no slack_event provided")
-            return {"statusCode": 400}
-
-        process_async_slack_event(slack_event_data=slack_event_data)
-        return {"statusCode": 200}
-
-    # handle async processing requests
+    app = get_app(logger=logger)
+    # handle pull request processing requests
     if event.get("pull_request_processing"):
         slack_event_data = event.get("slack_event")
         if not slack_event_data:

packages/slackBotFunction/app/services/app.py

@@ -1,23 +1,23 @@
 from functools import lru_cache
+import logging
 
 from slack_bolt import App
 from app.core.config import get_ssm_params
-from app.core.config import get_logger
 from app.slack.slack_handlers import setup_handlers
+from aws_lambda_powertools import Logger
 
-logger = get_logger()
 
-
-@lru_cache()
-def get_app() -> App:
+@lru_cache
+def get_app(logger: Logger) -> App:
     bot_token, signing_secret = get_ssm_params()
+    powertools_logger = logging.getLogger(name=logger.name)
 
     # initialise the Slack app
     app = App(
         process_before_response=True,
         token=bot_token,
         signing_secret=signing_secret,
-        logger=logger,
+        logger=powertools_logger,
     )
     setup_handlers(app)
     return app

packages/slackBotFunction/app/slack/slack_events.py

@@ -7,7 +7,7 @@
 import time
 import traceback
 import json
-from typing import Any, Dict, Tuple
+from typing import Any, Dict
 from botocore.exceptions import ClientError
 from slack_sdk import WebClient
 from app.core.config import (
@@ -25,7 +25,7 @@
 )
 from app.services.query_reformulator import reformulate_query
 from app.services.slack import get_friendly_channel_name, post_error_message
-from app.utils.handler_utils import extract_pull_request_id, is_duplicate_event
+from app.utils.handler_utils import extract_conversation_context, extract_pull_request_id, is_duplicate_event
 
 logger = get_logger()
 
@@ -103,17 +103,6 @@ def _mark_qa_feedback_received(conversation_key: str, message_ts: str) -> None:
 # ================================================================
 
 
-def _extract_conversation_context(event: Dict[str, Any]) -> Tuple[str, str, str | None]:
-    """Extract conversation key and thread context from event"""
-    channel = event["channel"]
-    # Determine conversation context: DM vs channel thread
-    if event.get("channel_type") == constants.CHANNEL_TYPE_IM:
-        return f"{constants.DM_PREFIX}{channel}", constants.CONTEXT_TYPE_DM, None  # DMs don't use threads
-    else:
-        thread_root = event.get("thread_ts", event["ts"])
-        return f"{constants.THREAD_PREFIX}{channel}#{thread_root}", constants.CONTEXT_TYPE_THREAD, thread_root
-
-
 def _handle_session_management(
     conversation_key: str,
     session_data: Dict[str, Any],
@@ -182,23 +171,21 @@ def _create_feedback_blocks(
 # ================================================================
 
 
-def process_async_slack_event(slack_event_data: Dict[str, Any]) -> None:
+def process_async_slack_event(event: Dict[str, Any], event_id: str) -> None:
     """
     Process Slack events asynchronously after initial acknowledgment
 
     This function handles the actual AI processing that takes longer than Slack's
     3-second timeout. It extracts the user query, calls Bedrock, and posts the response.
     """
-    event = slack_event_data["event"]
-    event_id = slack_event_data["event_id"]
     token = get_bot_token()
 
     client = WebClient(token=token)
 
     try:
         user_id = event["user"]
         channel = event["channel"]
-        conversation_key, context_type, thread_ts = _extract_conversation_context(event)
+        conversation_key, context_type, thread_ts = extract_conversation_context(event)
 
         # Remove Slack user mentions from message text
         user_query = re.sub(r"<@[UW][A-Z0-9]+(\|[^>]+)?>", "", event["text"]).strip()

packages/slackBotFunction/app/slack/slack_handlers.py

@@ -23,15 +23,15 @@
 from app.services.slack import post_error_message
 from app.utils.handler_utils import (
     conversation_key_and_root,
+    extract_conversation_context,
     extract_pull_request_id,
     gate_common,
     is_latest_message,
     strip_mentions,
-    trigger_async_processing,
     respond_with_eyes,
     trigger_pull_request_processing,
 )
-from app.slack.slack_events import _extract_conversation_context, store_feedback
+from app.slack.slack_events import process_async_slack_event, store_feedback
 
 logger = get_logger()
 
@@ -43,26 +43,29 @@
 @lru_cache
 def setup_handlers(app: App) -> None:
     """Register handlers. Intentionally minimal—no branching here."""
-    app.event("app_mention")(mention_handler)
-    app.event("message")(unified_message_handler)
-    app.action("feedback_yes")(feedback_handler)
-    app.action("feedback_no")(feedback_handler)
+    app.event("app_mention")(ack=respond_to_slack_within_3_seconds, lazy=[mention_handler])
+    app.event("message")(ack=respond_to_slack_within_3_seconds, lazy=[unified_message_handler])
+    app.action("feedback_yes")(ack=respond_to_slack_within_3_seconds, lazy=[feedback_handler])
+    app.action("feedback_no")(ack=respond_to_slack_within_3_seconds, lazy=[feedback_handler])
 
 
 # ================================================================
 # Event and message handlers
 # ================================================================
 
 
-def mention_handler(event: Dict[str, Any], ack: Ack, body: Dict[str, Any], client: WebClient) -> None:
+def respond_to_slack_within_3_seconds(event: Dict[str, Any], ack: Ack):
+    respond_with_eyes(event=event)
+    logger.debug("Sending ack response")
+    ack()
+
+
+def mention_handler(event: Dict[str, Any], body: Dict[str, Any], client: WebClient) -> None:
     """
     Channel interactions that mention the bot.
     - If text after the mention starts with 'feedback:', store it as additional feedback.
     - Otherwise, forward to the async processing pipeline (Q&A).
     """
-    logger.debug("Sending ack response in mention_handler")
-    ack()
-    respond_with_eyes(event=event)
     event_id = gate_common(event=event, body=body)
     if not event_id:
         return
@@ -133,6 +136,8 @@ def thread_message_handler(event: Dict[str, Any], event_id: str, client: WebClie
         logger.info(f"Found session for thread: {conversation_key}")
     except Exception as e:
         logger.error(f"Error checking thread session: {e}", extra={"error": traceback.format_exc()})
+        _, _, thread_ts = extract_conversation_context(event)
+        post_error_message(channel=channel_id, thread_ts=thread_ts)
         return
 
     logger.info(f"Processing thread message from user {user_id}", extra={"event_id": event_id})
@@ -147,11 +152,8 @@ def thread_message_handler(event: Dict[str, Any], event_id: str, client: WebClie
     )
 
 
-def unified_message_handler(event: Dict[str, Any], ack: Ack, body: Dict[str, Any], client: WebClient) -> None:
+def unified_message_handler(event: Dict[str, Any], body: Dict[str, Any], client: WebClient) -> None:
     """Handle all message events - DMs and channel messages"""
-    logger.debug("Sending ack response")
-    ack()
-    respond_with_eyes(event=event)
     event_id = gate_common(event=event, body=body)
     if not event_id:
         return
@@ -165,11 +167,10 @@ def unified_message_handler(event: Dict[str, Any], ack: Ack, body: Dict[str, Any
         thread_message_handler(event=event, event_id=event_id, client=client, body=body)
 
 
-def feedback_handler(ack: Ack, body: Dict[str, Any], client: WebClient) -> None:
+def feedback_handler(body: Dict[str, Any], client: WebClient, event: Dict[str, Any]) -> None:
     """Handle feedback button clicks (both positive and negative)."""
-    logger.debug("Sending ack response")
-    ack()
     try:
+        channel_id = event["channel"]
         action_id = body["actions"][0]["action_id"]
         feedback_data = json.loads(body["actions"][0]["value"])
 
@@ -215,8 +216,12 @@ def feedback_handler(ack: Ack, body: Dict[str, Any], client: WebClient) -> None:
             logger.error(f"Feedback storage error: {e}", extra={"error": traceback.format_exc()})
         except Exception as e:
             logger.error(f"Unexpected feedback error: {e}", extra={"error": traceback.format_exc()})
+            thread_ts = feedback_data.get("tt")
+            post_error_message(channel=channel_id, thread_ts=thread_ts)
     except Exception as e:
         logger.error(f"Error handling feedback: {e}", extra={"error": traceback.format_exc()})
+        _, _, thread_ts = extract_conversation_context(event)
+        post_error_message(channel=channel_id, thread_ts=thread_ts)
 
 
 # ================================================================
@@ -262,6 +267,8 @@ def _common_message_handler(
             client.chat_postMessage(**params)
         except Exception as e:
             logger.error(f"Failed to post channel feedback ack: {e}", extra={"error": traceback.format_exc()})
+            _, _, thread_ts = extract_conversation_context(event)
+            post_error_message(channel=channel_id, thread_ts=thread_ts)
         return
 
     if message_text.lower().startswith(constants.PULL_REQUEST_PREFIX):
@@ -270,13 +277,12 @@ def _common_message_handler(
             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()})
-            _, _, thread_ts = _extract_conversation_context(event)
+            _, _, thread_ts = extract_conversation_context(event)
             post_error_message(channel=channel_id, thread_ts=thread_ts)
         return
 
+    # note - we dont do post an error message if this fails as its handled by process_async_slack_event
     try:
-        trigger_async_processing(event=event, event_id=event_id)
+        process_async_slack_event(event=event, event_id=event_id)
     except Exception:
         logger.error("Error triggering async processing", extra={"error": traceback.format_exc()})
-        _, _, thread_ts = _extract_conversation_context(event)
-        post_error_message(channel=channel_id, thread_ts=thread_ts)

packages/slackBotFunction/app/utils/handler_utils.py

@@ -10,7 +10,6 @@
 import boto3
 from botocore.exceptions import ClientError
 from slack_sdk import WebClient
-import os
 from mypy_boto3_cloudformation.client import CloudFormationClient
 from mypy_boto3_lambda.client import LambdaClient
 
@@ -45,30 +44,6 @@ def is_duplicate_event(event_id: str) -> bool:
         return False
 
 
-def trigger_async_processing(event: Dict[str, Any], event_id: str) -> None:
-    """
-    Trigger asynchronous Lambda invocation to process Slack events
-
-    Slack requires responses within 3 seconds, but Bedrock queries can take longer.
-    This function invokes the same Lambda function asynchronously to handle the
-    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:
-        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(lambda_payload),
-        )
-        logger.debug("Async processing triggered successfully")
-    except Exception as e:
-        logger.error("Failed to trigger async processing", extra={"error": traceback.format_exc()})
-        raise e
-
-
 def respond_with_eyes(event: Dict[str, Any]) -> None:
     bot_token = get_bot_token()
     client = WebClient(token=bot_token)
@@ -172,3 +147,14 @@ def conversation_key_and_root(event: Dict[str, Any]) -> Tuple[str, str]:
     if event.get("channel_type") == constants.CHANNEL_TYPE_IM:
         return f"{constants.DM_PREFIX}{channel_id}", root
     return f"{constants.THREAD_PREFIX}{channel_id}#{root}", root
+
+
+def extract_conversation_context(event: Dict[str, Any]) -> Tuple[str, str, str | None]:
+    """Extract conversation key and thread context from event"""
+    channel = event["channel"]
+    # Determine conversation context: DM vs channel thread
+    if event.get("channel_type") == constants.CHANNEL_TYPE_IM:
+        return f"{constants.DM_PREFIX}{channel}", constants.CONTEXT_TYPE_DM, None  # DMs don't use threads
+    else:
+        thread_root = event.get("thread_ts", event["ts"])
+        return f"{constants.THREAD_PREFIX}{channel}#{thread_root}", constants.CONTEXT_TYPE_THREAD, thread_root

packages/slackBotFunction/tests/conftest.py

@@ -21,7 +21,6 @@ def mock_env():
         "AWS_REGION": "eu-west-2",
         "GUARD_RAIL_ID": "test-guard-id",
         "GUARD_RAIL_VERSION": "1",
-        "AWS_LAMBDA_FUNCTION_NAME": "test-function",
         "QUERY_REFORMULATION_MODEL_ID": "test-model",
         "QUERY_REFORMULATION_PROMPT_NAME": "test-prompt",
         "QUERY_REFORMULATION_PROMPT_VERSION": "DRAFT",