Use Slack Web API to process async Slack events

Author: kris-szlapa

packages/slackBotFunction/app.py

@@ -1,15 +1,16 @@
 import os
+import re
 import json
 import boto3
 from slack_bolt import App
 from slack_bolt.adapter.aws_lambda import SlackRequestHandler
+from slack_sdk import WebClient
 from aws_lambda_powertools import Logger
 from aws_lambda_powertools.utilities.parameters import get_parameter
 from aws_lambda_powertools.utilities.typing import LambdaContext
 
-# In-memory cache for processed events (Lambda container reuse)
+# Simple deduplication cache for edge case retries
 processed_events = set()
-MAX_PROCESSED_EVENTS = 1000  # Prevent memory growth
 
 # Initialize Powertools Logger
 logger = Logger(service="slackBotFunction")
@@ -52,72 +53,27 @@ def log_request(slack_logger, body, next):
     return next()
 
 
-def manage_processed_events_cache():
+def trigger_async_processing(event_data, context):
     """
-    Manage the size of processed_events cache to prevent memory issues.
+    Trigger async processing of the Slack event to avoid timeout issues.
     """
-    global processed_events
-    if len(processed_events) > MAX_PROCESSED_EVENTS:
-        # Keep only the most recent half to prevent memory growth
-        processed_events = set(list(processed_events)[-MAX_PROCESSED_EVENTS // 2 :])
-        logger.info(f"Cleaned processed_events cache, now has {len(processed_events)} items")
-
-
-def process_mention_request(event, say, event_id):
-    """
-    Process the @mention user query and proxy the query to Bedrock Knowledge base RetrieveAndGenerate API
-    and return the response to Slack to be presented in the thread.
-    """
-    try:
-        # Extract the user's query, removing the bot mention
-        raw_text = event["text"]
-        user_id = event["user"]
-        thread_ts = event.get("thread_ts", event["ts"])  # Use thread_ts if in thread, otherwise use message ts
-
-        # Remove bot mention from the text to get clean query
-        # Bot mentions come in format <@U1234567890> or <@U1234567890|botname>
-        import re
-
-        user_query = re.sub(r"<@[UW][A-Z0-9]+(\|[^>]+)?>", "", raw_text).strip()
-
-        logger.info(
-            f"Processing @mention from user {user_id}",
-            extra={"user_query": user_query, "thread_ts": thread_ts, "event_id": event_id},
-        )
-
-        if not user_query:
-            say(
-                text="Hi there! Please ask me a question and I'll help you find information from our knowledge base.",
-                thread_ts=thread_ts,
-            )
-            return
-
-        kb_response = get_bedrock_knowledgebase_response(user_query)
-        response_text = kb_response["output"]["text"]
-
-        # Reply in thread with the response
-        say(text=response_text, thread_ts=thread_ts)
-
-    except Exception as err:
-        logger.error(f"Error processing @mention: {err}", extra={"event_id": event_id})
-        thread_ts = event.get("thread_ts", event.get("ts"))
-        say(text="Sorry, an error occurred while processing your request. Please try again later.", thread_ts=thread_ts)
+    lambda_client = boto3.client("lambda")
+    lambda_client.invoke(
+        FunctionName=context.function_name,
+        InvocationType="Event",
+        Payload=json.dumps({"async_processing": True, "slack_event": event_data}),
+    )
 
 
 def get_bedrock_knowledgebase_response(user_query):
     """
     Get and return the Bedrock Knowledge Base RetrieveAndGenerate response.
-    Do all init tasks here instead of globally as initial invocation of this lambda
-    provides Slack required ack in 3 sec. It doesn't trigger any bedrock functions and is
-    time sensitive.
     """
-    # Initialise the bedrock-runtime client (in default / running region).
     client = boto3.client(
         service_name="bedrock-agent-runtime",
         region_name=AWS_REGION,
     )
 
-    # Create the RetrieveAndGenerateCommand input with the user query.
     query_input = {
         "text": user_query,
     }
@@ -141,11 +97,53 @@ def get_bedrock_knowledgebase_response(user_query):
     return response
 
 
+def process_async_slack_event(slack_event_data):
+    """Process Slack event asynchronously"""
+    event = slack_event_data["event"]
+    event_id = slack_event_data["event_id"]
+    token = slack_event_data["bot_token"]
+
+    client = WebClient(token=token)
+
+    try:
+        raw_text = event["text"]
+        user_id = event["user"]
+        channel = event["channel"]
+        thread_ts = event.get("thread_ts", event["ts"])
+
+        user_query = re.sub(r"<@[UW][A-Z0-9]+(\|[^>]+)?>", "", raw_text).strip()
+
+        logger.info(
+            f"Processing async @mention from user {user_id}",
+            extra={"user_query": user_query, "thread_ts": thread_ts, "event_id": event_id},
+        )
+
+        if not user_query:
+            client.chat_postMessage(
+                channel=channel,
+                text="Hi there! Please ask me a question and I'll help you find information from our knowledge base.",
+                thread_ts=thread_ts,
+            )
+            return
+
+        kb_response = get_bedrock_knowledgebase_response(user_query)
+        response_text = kb_response["output"]["text"]
+
+        client.chat_postMessage(channel=channel, text=response_text, thread_ts=thread_ts)
+
+    except Exception as err:
+        logger.error(f"Error processing async @mention: {err}", extra={"event_id": event_id})
+        client.chat_postMessage(
+            channel=channel,
+            text="Sorry, an error occurred while processing your request. Please try again later.",
+            thread_ts=thread_ts,
+        )
+
+
 # Handle @mentions in channels and DMs
 @app.event("app_mention")
-def handle_app_mention(event, say, ack, body):
+def handle_app_mention(event, say, ack, body, context):
     """Handle when the bot is @mentioned"""
-    # Use the official event_id from Slack for deduplication
     event_id = body.get("event_id")
 
     # Check if we've already processed this event
@@ -154,9 +152,8 @@ def handle_app_mention(event, say, ack, body):
         ack()
         return
 
-    # Mark event as processed and manage cache size
+    # Mark event as processed
     processed_events.add(event_id)
-    manage_processed_events_cache()
 
     # Acknowledge immediately to prevent Slack retries
     ack()
@@ -165,17 +162,16 @@ def handle_app_mention(event, say, ack, body):
     user_id = event.get("user", "unknown")
     logger.info(f"Acknowledged @mention from user {user_id}", extra={"event_id": event_id})
 
-    # Process the actual request
-    process_mention_request(event, say, event_id)
+    # Trigger async processing
+    trigger_async_processing({"event": event, "event_id": event_id, "bot_token": bot_token}, context)
 
 
 # Handle direct messages
 @app.event("message")
-def handle_direct_message(event, say, ack, body):
+def handle_direct_message(event, say, ack, body, context):
     """Handle direct messages to the bot"""
     # Only respond to direct messages (not channel messages)
     if event.get("channel_type") == "im":
-        # Use the official event_id from Slack for deduplication
         event_id = body.get("event_id")
 
         # Check if we've already processed this event
@@ -184,9 +180,8 @@ def handle_direct_message(event, say, ack, body):
             ack()
             return
 
-        # Mark event as processed and manage cache size
+        # Mark event as processed
         processed_events.add(event_id)
-        manage_processed_events_cache()
 
         # Acknowledge immediately to prevent Slack retries
         ack()
@@ -195,13 +190,17 @@ def handle_direct_message(event, say, ack, body):
         user_id = event.get("user", "unknown")
         logger.info(f"Acknowledged DM from user {user_id}", extra={"event_id": event_id})
 
-        # Process the actual request
-        process_mention_request(event, say, event_id)
+        # Trigger async processing
+        trigger_async_processing({"event": event, "event_id": event_id, "bot_token": bot_token}, context)
 
 
-# Lambda handler method.
 @logger.inject_lambda_context
 def handler(event: dict, context: LambdaContext) -> dict:
     logger.info("Lambda invoked for Slack bot", extra={"event": event})
+
+    if event.get("async_processing"):
+        process_async_slack_event(event["slack_event"])
+        return {"statusCode": 200}
+
     slack_handler = SlackRequestHandler(app=app)
     return slack_handler.handle(event, context)