Retrospective: Adopting Async Communication with Slack 5.0 and Loom 3.0 for 200 Engineers

# Import required dependencies
import os
import json
from datetime import datetime, timedelta
from slack_sdk.web import WebClient
from slack_sdk.errors import SlackApiError
import time

# Load environment variables for Slack API token and channel IDs
SLACK_BOT_TOKEN = os.environ.get("SLACK_BOT_TOKEN")
STANDUP_CHANNEL_ID = os.environ.get("STANDUP_CHANNEL_ID")
SUMMARY_CHANNEL_ID = os.environ.get("SUMMARY_CHANNEL_ID")

# Initialize Slack Web Client with retry logic for rate limits
client = WebClient(token=SLACK_BOT_TOKEN, timeout=30)

def send_standup_prompt():
    """Send daily async standup prompt to the team channel via Slack 5.0 Workflow Builder"""
    today = datetime.now().strftime("%Y-%m-%d")
    prompt_blocks = [
        {
            "type": "header",
            "text": {
                "type": "plain_text",
                "text": f"🗓️ Async Standup: {today}",
                "emoji": True
            }
        },
        {
            "type": "section",
            "text": {
                "type": "mrkdwn",
                "text": "Reply in a thread to this message with:\n1. What you completed yesterday\n2. What you're working on today\n3. Any blockers (if none, say 'No blockers')"
            }
        },
        {
            "type": "divider"
        },
        {
            "type": "context",
            "elements": [
                {
                    "type": "mrkdwn",
                    "text": "This is an automated message from Slack 5.0 Workflow Builder. Do not reply via DM."
                }
            ]
        }
    ]
    try:
        response = client.chat_postMessage(
            channel=STANDUP_CHANNEL_ID,
            blocks=prompt_blocks,
            text=f"Async Standup Prompt for {today}"  # Fallback text for notifications
        )
        print(f"Standup prompt sent successfully: {response['ts']}")
        return response["ts"]  # Return timestamp to track replies
    except SlackApiError as e:
        print(f"Error sending standup prompt: {e.response['error']}")
        if e.response["error"] == "ratelimited":
            retry_after = int(e.response.headers.get("Retry-After", 60))
            print(f"Rate limited. Retrying after {retry_after} seconds.")
            time.sleep(retry_after)
            return send_standup_prompt()  # Retry recursively
        return None

def collect_standup_responses(prompt_ts):
    """Collect all threaded replies to the standup prompt"""
    if not prompt_ts:
        return []
    responses = []
    try:
        # Fetch all replies to the prompt message
        result = client.conversations_replies(
            channel=STANDUP_CHANNEL_ID,
            ts=prompt_ts
        )
        # Skip the original prompt message (index 0)
        for msg in result["messages"][1:]:
            user = msg.get("user", "unknown")
            text = msg.get("text", "")
            responses.append({"user": user, "text": text})
        return responses
    except SlackApiError as e:
        print(f"Error collecting responses: {e.response['error']}")
        return []

def post_standup_summary(prompt_ts, responses):
    """Post a summary of standup responses to the summary channel"""
    if not responses:
        summary_text = "No standup responses today."
    else:
        summary_lines = ["📝 *Daily Standup Summary*"]
        for resp in responses:
            # Fetch user info to get display name
            try:
                user_info = client.users_info(user=resp["user"])
                display_name = user_info["user"]["profile"]["display_name"] or user_info["user"]["name"]
            except SlackApiError:
                display_name = resp["user"]
            summary_lines.append(f"*{display_name}*: {resp['text'][:200]}")  # Truncate long responses
        summary_text = "\n".join(summary_lines)
    try:
        client.chat_postMessage(
            channel=SUMMARY_CHANNEL_ID,
            text=summary_text,
            thread_ts=prompt_ts  # Link summary to original prompt thread
        )
        print("Standup summary posted successfully.")
    except SlackApiError as e:
        print(f"Error posting summary: {e.response['error']}")

if __name__ == "__main__":
    # Validate environment variables
    if not all([SLACK_BOT_TOKEN, STANDUP_CHANNEL_ID, SUMMARY_CHANNEL_ID]):
        raise ValueError("Missing required environment variables. Set SLACK_BOT_TOKEN, STANDUP_CHANNEL_ID, SUMMARY_CHANNEL_ID.")
    # Send prompt and collect responses (wait 8 hours for replies before summarizing)
    prompt_ts = send_standup_prompt()
    if prompt_ts:
        print("Waiting 8 hours for standup replies...")
        time.sleep(8 * 60 * 60)  # 8 hours
        responses = collect_standup_responses(prompt_ts)
        post_standup_summary(prompt_ts, responses)
    else:
        print("Failed to send standup prompt. Exiting.")

# Import required dependencies
import os
import json
import time
from datetime import datetime, timedelta
from slack_sdk.web import WebClient
from slack_sdk.errors import SlackApiError
import requests  # For Loom API calls (Loom doesn't have an official Python SDK)

# Load environment variables
SLACK_BOT_TOKEN = os.environ.get("SLACK_BOT_TOKEN")
LOOM_API_KEY = os.environ.get("LOOM_API_KEY")
TARGET_SLACK_CHANNEL = os.environ.get("LOOM_SYNC_CHANNEL_ID")
# Loom API base URL (see https://github.com/loom/loom-api-docs for reference)
LOOM_API_BASE = "https://api.loom.com"

# Initialize Slack client
slack_client = WebClient(token=SLACK_BOT_TOKEN)

def get_loom_headers():
    """Return headers for Loom API requests"""
    return {
        "Authorization": f"Bearer {LOOM_API_KEY}",
        "Content-Type": "application/json"
    }

def fetch_new_loom_videos(last_sync_time):
    """Fetch all Loom videos created after last_sync_time"""
    videos = []
    page = 1
    per_page = 25
    while True:
        try:
            response = requests.get(
                f"{LOOM_API_BASE}/v1/videos",
                headers=get_loom_headers(),
                params={
                    "page": page,
                    "per_page": per_page,
                    "created_at[gt]": int(last_sync_time.timestamp())
                }
            )
            response.raise_for_status()  # Raise exception for HTTP errors
            data = response.json()
            videos.extend(data.get("videos", []))
            # Check if there are more pages
            if len(data.get("videos", [])) < per_page:
                break
            page += 1
            time.sleep(1)  # Rate limit buffer
        except requests.exceptions.RequestException as e:
            print(f"Error fetching Loom videos: {e}")
            if hasattr(e, "response") and e.response.status_code == 429:
                retry_after = int(e.response.headers.get("Retry-After", 60))
                print(f"Loom rate limited. Retrying after {retry_after} seconds.")
                time.sleep(retry_after)
                continue
            break
    return videos

def get_loom_transcription(video_id):
    """Fetch automatic transcription for a Loom video (Loom 3.0 feature)"""
    try:
        response = requests.get(
            f"{LOOM_API_BASE}/v1/videos/{video_id}/transcription",
            headers=get_loom_headers()
        )
        response.raise_for_status()
        return response.json().get("text", "No transcription available.")
    except requests.exceptions.RequestException as e:
        print(f"Error fetching transcription for video {video_id}: {e}")
        return "Transcription unavailable."

def post_loom_video_to_slack(video, transcription):
    """Post Loom video details and transcription to Slack channel"""
    video_url = video.get("url", "")
    video_title = video.get("title", "Untitled Loom Video")
    created_at = datetime.fromtimestamp(video.get("created_at", 0)).strftime("%Y-%m-%d %H:%M")
    blocks = [
        {
            "type": "section",
            "text": {
                "type": "mrkdwn",
                "text": f"*New Loom Video Posted*\n*Title*: {video_title}\n*Created*: {created_at}\n*Link*: {video_url}"
            }
        },
        {
            "type": "section",
            "text": {
                "type": "mrkdwn",
                "text": f"*Transcription Preview*:\n{transcription[:500]}{'...' if len(transcription) > 500 else ''}"
            }
        },
        {
            "type": "divider"
        }
    ]
    try:
        slack_client.chat_postMessage(
            channel=TARGET_SLACK_CHANNEL,
            blocks=blocks,
            text=f"New Loom Video: {video_title}"  # Fallback text
        )
        print(f"Posted Loom video {video_id} to Slack.")
        return True
    except SlackApiError as e:
        print(f"Error posting to Slack: {e.response['error']}")
        return False

if __name__ == "__main__":
    # Validate env vars
    if not all([SLACK_BOT_TOKEN, LOOM_API_KEY, TARGET_SLACK_CHANNEL]):
        raise ValueError("Missing env vars: SLACK_BOT_TOKEN, LOOM_API_KEY, LOOM_SYNC_CHANNEL_ID")
    # Last sync time: 24 hours ago (initial run)
    last_sync = datetime.now() - timedelta(days=1)
    # Load last sync time from file if exists
    SYNC_STATE_FILE = "loom_sync_state.json"
    if os.path.exists(SYNC_STATE_FILE):
        with open(SYNC_STATE_FILE, "r") as f:
            state = json.load(f)
            last_sync = datetime.fromtimestamp(state.get("last_sync", last_sync.timestamp()))
    # Fetch new videos
    print(f"Fetching Loom videos created after {last_sync}...")
    new_videos = fetch_new_loom_videos(last_sync)
    print(f"Found {len(new_videos)} new videos.")
    # Process each video
    for video in new_videos:
        video_id = video.get("id")
        transcription = get_loom_transcription(video_id)
        post_loom_video_to_slack(video, transcription)
        time.sleep(2)  # Rate limit buffer
    # Update sync state
    with open(SYNC_STATE_FILE, "w") as f:
        json.dump({"last_sync": datetime.now().timestamp()}, f)
    print("Sync completed successfully.")

# Import dependencies
import os
import json
import time
from datetime import datetime, timedelta
from slack_sdk.web import WebClient
from slack_sdk.errors import SlackApiError
import requests
import pandas as pd

# Env vars
SLACK_BOT_TOKEN = os.environ.get("SLACK_BOT_TOKEN")
LOOM_API_KEY = os.environ.get("LOOM_API_KEY")
# Loom API base (https://github.com/loom/loom-api-docs)
LOOM_API_BASE = "https://api.loom.com"

# Initialize clients
slack_client = WebClient(token=SLACK_BOT_TOKEN)

def get_slack_channel_history(channel_id, start_time, end_time):
    """Fetch all messages in a Slack channel between start and end time"""
    messages = []
    cursor = None
    while True:
        try:
            response = slack_client.conversations_history(
                channel=channel_id,
                oldest=start_time,
                latest=end_time,
                cursor=cursor,
                limit=200
            )
            messages.extend(response["messages"])
            if not response["has_more"]:
                break
            cursor = response["response_metadata"]["next_cursor"]
            time.sleep(1)  # Rate limit buffer
        except SlackApiError as e:
            print(f"Slack API error: {e.response['error']}")
            if e.response["error"] == "ratelimited":
                retry_after = int(e.response.headers.get("Retry-After", 60))
                time.sleep(retry_after)
                continue
            break
    return messages

def calculate_slack_metrics(messages):
    """Calculate async communication metrics from Slack messages"""
    total_messages = len(messages)
    threaded_replies = sum(1 for msg in messages if msg.get("thread_ts") and msg["thread_ts"] != msg.get("ts"))
    sync_mentions = sum(1 for msg in messages if "@channel" in msg.get("text", "") or "@here" in msg.get("text", ""))
    return {
        "total_messages": total_messages,
        "threaded_replies": threaded_replies,
        "sync_mentions": sync_mentions,
        "async_ratio": threaded_replies / total_messages if total_messages > 0 else 0
    }

def get_loom_video_count(start_time, end_time):
    """Get number of Loom videos created between start and end time"""
    count = 0
    page = 1
    per_page = 25
    while True:
        try:
            response = requests.get(
                f"{LOOM_API_BASE}/v1/videos",
                headers={"Authorization": f"Bearer {LOOM_API_KEY}"},
                params={
                    "page": page,
                    "per_page": per_page,
                    "created_at[gt]": start_time,
                    "created_at[lt]": end_time
                }
            )
            response.raise_for_status()
            data = response.json()
            count += len(data.get("videos", []))
            if len(data.get("videos", [])) < per_page:
                break
            page += 1
            time.sleep(1)
        except requests.exceptions.RequestException as e:
            print(f"Loom API error: {e}")
            break
    return count

def generate_metrics_report(pre_start, pre_end, post_start, post_end, slack_channels):
    """Generate pre/post adoption metrics report"""
    report = {
        "pre_adoption": {},
        "post_adoption": {},
        "improvement": {}
    }
    # Pre-adoption Slack metrics
    pre_slack_msgs = []
    for channel in slack_channels:
        pre_slack_msgs.extend(get_slack_channel_history(channel, pre_start, pre_end))
    pre_slack_metrics = calculate_slack_metrics(pre_slack_msgs)
    report["pre_adoption"]["slack"] = pre_slack_metrics
    # Post-adoption Slack metrics
    post_slack_msgs = []
    for channel in slack_channels:
        post_slack_msgs.extend(get_slack_channel_history(channel, post_start, post_end))
    post_slack_metrics = calculate_slack_metrics(post_slack_msgs)
    report["post_adoption"]["slack"] = post_slack_metrics
    # Loom metrics
    report["pre_adoption"]["loom_video_count"] = get_loom_video_count(pre_start, pre_end)
    report["post_adoption"]["loom_video_count"] = get_loom_video_count(post_start, post_end)
    # Calculate improvements
    report["improvement"]["async_ratio_change"] = post_slack_metrics["async_ratio"] - pre_slack_metrics["async_ratio"]
    report["improvement"]["sync_mention_reduction"] = (pre_slack_metrics["sync_mentions"] - post_slack_metrics["sync_mentions"]) / pre_slack_metrics["sync_mentions"] if pre_slack_metrics["sync_mentions"] >0 else 0
    return report

if __name__ == "__main__":
    # Validate env vars
    if not all([SLACK_BOT_TOKEN, LOOM_API_KEY]):
        raise ValueError("Missing env vars: SLACK_BOT_TOKEN, LOOM_API_KEY")
    # Define time ranges (Q3 2023 pre-adoption, Q1 2024 post-adoption)
    pre_start = int(datetime(2023, 7, 1).timestamp())
    pre_end = int(datetime(2023, 9, 30).timestamp())
    post_start = int(datetime(2024, 1, 1).timestamp())
    post_end = int(datetime(2024, 3, 31).timestamp())
    # Slack channels to analyze (all async channels)
    slack_channels = [
        "C12345678",  # Replace with actual channel IDs
        "C87654321",
        "C11223344"
    ]
    # Generate report
    print("Generating metrics report...")
    report = generate_metrics_report(pre_start, pre_end, post_start, post_end, slack_channels)
    # Print report
    print(json.dumps(report, indent=2))
    # Save to file
    with open("async_metrics_report.json", "w") as f:
        json.dump(report, f, indent=2)
    print("Report saved to async_metrics_report.json")

# Bulk rename Slack channels to enforce [async]/[sync] prefix
import os
from slack_sdk.web import WebClient

client = WebClient(token=os.environ["SLACK_BOT_TOKEN"])
# Map of old channel ID to new name
channel_renames = {
    "C123456": "[async]-backend",
    "C789012": "[sync]-incident-response",
    "C345678": "[async]-frontend-design"
}

for channel_id, new_name in channel_renames.items():
    try:
        client.conversations_rename(channel=channel_id, name=new_name)
        print(f"Renamed {channel_id} to {new_name}")
    except Exception as e:
        print(f"Error renaming {channel_id}: {e}")

# Add a timestamped annotation to a Loom video via Loom 3.0 API
import requests

LOOM_API_KEY = "your-loom-api-key"
video_id = "abc123"
annotation_data = {
    "timestamp": 125,  # 2 minutes 5 seconds into the video
    "text": "Potential null pointer issue in user validation logic",
    "x": 0.5,  # X coordinate of annotation on video
    "y": 0.3   # Y coordinate of annotation on video
}

response = requests.post(
    f"https://api.loom.com/v1/videos/{video_id}/annotations",
    headers={"Authorization": f"Bearer {LOOM_API_KEY}"},
    json=annotation_data
)
print(response.json())

# Export Slack response latency as a Prometheus metric
from prometheus_client import Gauge, start_http_server
import time

response_latency = Gauge("slack_response_latency_minutes", "p99 cross-team response latency in minutes")

def update_metric():
    # Replace with actual logic to calculate p99 latency from Slack API
    p99_latency = 47  # Example value from Q1 2024
    response_latency.set(p99_latency)

if __name__ == "__main__":
    start_http_server(8000)  # Expose metrics on port 8000
    while True:
        update_metric()
        time.sleep(60)  # Update every minute