War Story: My First Year as a Staff Engineer at Google: Lessons Learned Using Jira 11.0 and Slack 5.0

import os
import time
import logging
from typing import Dict, Optional
from jira import JIRA, JIRAError
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# Configure logging for production debugging
logging.basicConfig(
    level=logging.INFO,
    format=\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\",
    handlers=[logging.StreamHandler(), logging.FileHandler(\"jira_slack_sync.log\")]
)
logger = logging.getLogger(__name__)

# Initialize Jira 11.0 client with personal access token
JIRA_SERVER = os.getenv(\"JIRA_SERVER\", \"https://jira.google.com\")
JIRA_PAT = os.getenv(\"JIRA_PAT\")
if not JIRA_PAT:
    logger.error(\"Missing JIRA_PAT environment variable\")
    raise ValueError(\"JIRA_PAT must be set\")

jira_client = JIRA(
    server=JIRA_SERVER,
    token_auth=JIRA_PAT,
    options={\"rest_api_version\": \"11\"}  # Pin to Jira 11.0 API
)

# Initialize Slack 5.0 client with bot token
SLACK_BOT_TOKEN = os.getenv(\"SLACK_BOT_TOKEN\")
if not SLACK_BOT_TOKEN:
    logger.error(\"Missing SLACK_BOT_TOKEN environment variable\")
    raise ValueError(\"SLACK_BOT_TOKEN must be set\")

slack_client = WebClient(token=SLACK_BOT_TOKEN)
# Verify Slack 5.0 client connectivity
try:
    slack_auth_test = slack_client.auth_test()
    logger.info(f\"Slack 5.0 client connected as {slack_auth_test['user']}\")
except SlackApiError as e:
    logger.error(f\"Slack 5.0 auth failed: {e.response['error']}\")
    raise

def fetch_updated_tickets(last_check_time: str) -> list:
    \"\"\"Fetch Jira 11.0 tickets updated since last_check_time, with retry logic.\"\"\"
    max_retries = 3
    retry_delay = 2  # seconds
    for attempt in range(max_retries):
        try:
            jql_query = f\"updated >= '{last_check_time}' AND project = 'GOOG-BE' ORDER BY updated ASC\"
            tickets = jira_client.search_issues(jql_query, maxResults=100)
            logger.info(f\"Fetched {len(tickets)} updated tickets from Jira 11.0\")
            return tickets
        except JIRAError as e:
            logger.warning(f\"Jira 11.0 fetch attempt {attempt+1} failed: {e.status_code} {e.text}\")
            if attempt < max_retries - 1:
                time.sleep(retry_delay * (2 ** attempt))  # Exponential backoff
            else:
                logger.error(\"Max retries exceeded for Jira 11.0 ticket fetch\")
                raise
    return []

def post_ticket_to_slack(ticket: object, channel: str = \"#staff-eng-updates\") -> None:
    \"\"\"Post Jira 11.0 ticket summary to Slack 5.0 channel with error handling.\"\"\"
    try:
        ticket_url = f\"{JIRA_SERVER}/browse/{ticket.key}\"
        message_blocks = [
            {
                \"type\": \"header\",
                \"text\": {\"type\": \"plain_text\", \"text\": f\"🎟️ Jira 11.0 Update: {ticket.key}\"}
            },
            {
                \"type\": \"section\",
                \"text\": {\"type\": \"mrkdwn\", \"text\": f\"*Summary:* {ticket.fields.summary}\"}
            },
            {
                \"type\": \"section\",
                \"text\": {\"type\": \"mrkdwn\", \"text\": f\"*Status:* {ticket.fields.status.name}\n*Assignee:* {ticket.fields.assignee.displayName if ticket.fields.assignee else 'Unassigned'}\"}
            },
            {
                \"type\": \"actions\",
                \"elements\": [
                    {
                        \"type\": \"button\",
                        \"text\": {\"type\": \"plain_text\", \"text\": \"Open in Jira 11.0\"},
                        \"url\": ticket_url
                    }
                ]
            }
        ]
        slack_client.chat_postMessage(
            channel=channel,
            blocks=message_blocks,
            text=f\"Jira 11.0 ticket {ticket.key} updated\"  # Fallback text
        )
        logger.info(f\"Posted ticket {ticket.key} to Slack 5.0 channel {channel}\")
    except SlackApiError as e:
        logger.error(f\"Failed to post {ticket.key} to Slack 5.0: {e.response['error']}\")
        # Retry once for rate limit errors
        if e.response[\"error\"] == \"ratelimited\":
            time.sleep(int(e.response.headers.get(\"Retry-After\", 5)))
            post_ticket_to_slack(ticket, channel)
    except Exception as e:
        logger.error(f\"Unexpected error posting {ticket.key}: {str(e)}\")

if __name__ == \"__main__\":
    last_check = \"2024-01-01 00:00\"
    logger.info(\"Starting Jira 11.0 -> Slack 5.0 sync service\")
    while True:
        try:
            updated_tickets = fetch_updated_tickets(last_check)
            for ticket in updated_tickets:
                post_ticket_to_slack(ticket)
                last_check = ticket.fields.updated  # Update last check time to latest ticket
            time.sleep(60)  # Poll every 60 seconds
        except KeyboardInterrupt:
            logger.info(\"Sync service stopped by user\")
            break
        except Exception as e:
            logger.error(f\"Main loop error: {str(e)}\")
            time.sleep(10)

import os
import re
import logging
from typing import Dict, Tuple
from flask import Flask, request, jsonify
from jira import JIRA, JIRAError
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError
from dotenv import load_dotenv

load_dotenv()

logging.basicConfig(
    level=logging.INFO,
    format=\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\"
)
logger = logging.getLogger(__name__)

app = Flask(__name__)

# Initialize clients (reuse from first example, but scoped here)
JIRA_SERVER = os.getenv(\"JIRA_SERVER\", \"https://jira.google.com\")
JIRA_PAT = os.getenv(\"JIRA_PAT\")
SLACK_BOT_TOKEN = os.getenv(\"SLACK_BOT_TOKEN\")

jira_client = JIRA(server=JIRA_SERVER, token_auth=JIRA_PAT, options={\"rest_api_version\": \"11\"})
slack_client = WebClient(token=SLACK_BOT_TOKEN)

# Slash command validation regex for Jira 11.0 ticket summary
SUMMARY_REGEX = re.compile(r'^/jira-create\s+(?P

import os
import time
import logging
from typing import Dict, Optional
from jira import JIRA, JIRAError
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError
from dotenv import load_dotenv

load_dotenv()

logging.basicConfig(
    level=logging.INFO,
    format=\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\",
    handlers=[logging.StreamHandler(), logging.FileHandler(\"jira_auto_assign.log\")]
)
logger = logging.getLogger(__name__)

# Initialize clients
JIRA_SERVER = os.getenv(\"JIRA_SERVER\", \"https://jira.google.com\")
JIRA_PAT = os.getenv(\"JIRA_PAT\")
SLACK_BOT_TOKEN = os.getenv(\"SLACK_BOT_TOKEN\")
SLACK_WORKSPACE_ID = os.getenv(\"SLACK_WORKSPACE_ID\", \"T12345678\")  # Google internal workspace

jira_client = JIRA(server=JIRA_SERVER, token_auth=JIRA_PAT, options={\"rest_api_version\": \"11\"})
slack_client = WebClient(token=SLACK_BOT_TOKEN)

# Map Jira 11.0 project keys to Slack 5.0 team channel IDs
PROJECT_SLACK_MAP = {
    \"GOOG-BE\": \"#backend-team\",
    \"GOOG-FE\": \"#frontend-team\",
    \"GOOG-CLOUD\": \"#cloud-infra\"
}

def get_slack_user_presence(slack_user_id: str) -> Optional[str]:
    \"\"\"Fetch Slack 5.0 user presence with rate limit handling.\"\"\"
    try:
        presence_resp = slack_client.users_getPresence(user=slack_user_id)
        return presence_resp.get(\"presence\")  # \"active\", \"away\", etc.
    except SlackApiError as e:
        if e.response[\"error\"] == \"ratelimited\":
            retry_after = int(e.response.headers.get(\"Retry-After\", 10))
            logger.warning(f\"Slack 5.0 rate limit hit, retrying after {retry_after}s\")
            time.sleep(retry_after)
            return get_slack_user_presence(slack_user_id)
        logger.error(f\"Failed to get presence for {slack_user_id}: {e.response['error']}\")
        return None

def get_available_team_members(project_key: str) -> list:
    \"\"\"Get active Slack 5.0 users mapped to Jira 11.0 project contributors.\"\"\"
    # In production, this would pull from Jira project role members
    project_members = {
        \"GOOG-BE\": [\"U123456\", \"U234567\", \"U345678\"],  # Slack user IDs
        \"GOOG-FE\": [\"U456789\", \"U567890\"],
        \"GOOG-CLOUD\": [\"U678901\", \"U789012\", \"U890123\"]
    }
    if project_key not in project_members:
        logger.warning(f\"No team members mapped for project {project_key}\")
        return []

    available_members = []
    for slack_id in project_members[project_key]:
        presence = get_slack_user_presence(slack_id)
        if presence == \"active\":
            # Map Slack ID to Jira 11.0 account ID (simplified)
            jira_user = jira_client.search_users(query=f\"{slack_id}@google.com\", maxResults=1)
            if jira_user:
                available_members.append(jira_user[0].accountId)
    logger.info(f\"Found {len(available_members)} active members for {project_key}\")
    return available_members

def auto_assign_ticket(ticket: object) -> None:
    \"\"\"Auto-assign unassigned Jira 11.0 ticket to available Slack 5.0 active team member.\"\"\"
    if ticket.fields.assignee:
        logger.debug(f\"Ticket {ticket.key} already assigned, skipping\")
        return

    project_key = ticket.fields.project.key
    available_members = get_available_team_members(project_key)
    if not available_members:
        logger.warning(f\"No available members to assign {ticket.key}\")
        # Post to Slack 5.0 team channel for manual assignment
        if project_key in PROJECT_SLACK_MAP:
            try:
                slack_client.chat_postMessage(
                    channel=PROJECT_SLACK_MAP[project_key],
                    text=f\"⚠️ Unassigned ticket {ticket.key} has no active team members: {ticket.fields.summary}\"
                )
            except SlackApiError as e:
                logger.error(f\"Failed to post to Slack 5.0: {e.response['error']}\")
        return

    # Round-robin assignment (simplified: pick first available)
    assignee_account_id = available_members[0]
    try:
        ticket.update(assignee={\"accountId\": assignee_account_id})
        logger.info(f\"Auto-assigned {ticket.key} to {assignee_account_id}\")
        # Post to Slack 5.0 channel
        if project_key in PROJECT_SLACK_MAP:
            slack_client.chat_postMessage(
                channel=PROJECT_SLACK_MAP[project_key],
                text=f\"✅ Auto-assigned {ticket.key} to <@{assignee_account_id}> (active in Slack 5.0)\"
            )
    except JIRAError as e:
        logger.error(f\"Failed to assign {ticket.key}: {e.status_code} {e.text}\")

def run_auto_assigner(poll_interval: int = 300) -> None:
    \"\"\"Main loop to poll for unassigned Jira 11.0 tickets and auto-assign.\"\"\"
    logger.info(\"Starting Jira 11.0 auto-assigner with Slack 5.0 presence checks\")
    while True:
        try:
            # Fetch unassigned tickets across mapped projects
            project_keys = \",\".join(PROJECT_SLACK_MAP.keys())
            jql_query = f\"assignee is EMPTY AND project in ({project_keys}) AND status != 'Done' ORDER BY created ASC\"
            unassigned_tickets = jira_client.search_issues(jql_query, maxResults=50)
            logger.info(f\"Found {len(unassigned_tickets)} unassigned tickets\")
            for ticket in unassigned_tickets:
                auto_assign_ticket(ticket)
            time.sleep(poll_interval)
        except KeyboardInterrupt:
            logger.info(\"Auto-assigner stopped by user\")
            break
        except JIRAError as e:
            logger.error(f\"Jira 11.0 poll failed: {e.status_code} {e.text}\")
            time.sleep(60)
        except Exception as e:
            logger.error(f\"Unexpected error in auto-assigner: {str(e)}\")
            time.sleep(60)

if __name__ == \"__main__\":
    run_auto_assigner()

# Bad: No API version pin
jira_client = JIRA(server=JIRA_SERVER, token_auth=JIRA_PAT)

# Good: Explicit Jira 11.0 API pin
jira_client = JIRA(
    server=JIRA_SERVER,
    token_auth=JIRA_PAT,
    options={\"rest_api_version\": \"11\"}  # Matches Jira 11.0 server
)

# Validate server version on startup
try:
    server_info = jira_client.server_info()
    if not server_info[\"version\"].startswith(\"11.\"):
        logger.error(f\"Jira server version {server_info['version']} does not match pinned 11.0\")
        raise RuntimeError(\"Jira version mismatch\")
except JIRAError as e:
    logger.error(f\"Failed to fetch Jira server info: {e.text}\")

# Slack 5.0 bot to enforce thread-only Jira discussions
import re
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError

JIRA_TICKET_REGEX = re.compile(r'[A-Z]+-\d+')  # Matches GOOG-BE-1234 style keys

def enforce_jira_thread_only(slack_client: WebClient, event: dict) -> None:
    \"\"\"Delete top-level messages with Jira keys, post thread link.\"\"\"
    channel = event.get(\"channel\")
    user = event.get(\"user\")
    text = event.get(\"text\", \"\")
    thread_ts = event.get(\"thread_ts\")  # None if top-level

    if thread_ts:
        return  # Already in a thread, no action

    if JIRA_TICKET_REGEX.search(text):
        try:
            # Delete the top-level message
            slack_client.chat_delete(channel=channel, ts=event[\"ts\"])
            # Post ephemeral message to user
            slack_client.chat_postEphemeral(
                channel=channel,
                user=user,
                text=\"❌ Jira ticket discussions must be in threads. Please use the thread linked to the ticket.\"
            )
        except SlackApiError as e:
            logger.error(f\"Failed to enforce thread rule: {e.response['error']}\")

# Jira 11.0 permission check for Slack bot
def validate_bot_permissions(jira_client: JIRA, project_key: str) -> bool:
    \"\"\"Check if bot has minimum required permissions for project.\"\"\"
    required_permissions = [\"BROWSE_PROJECTS\", \"CREATE_ISSUES\", \"EDIT_ISSUES\", \"ADD_COMMENTS\"]
    try:
        # Get bot's permissions for the project
        permissions = jira_client.my_permissions(projectKey=project_key)
        for perm in required_permissions:
            if not permissions[\"permissions\"][perm][\"havePermission\"]:
                logger.error(f\"Bot missing required permission {perm} for {project_key}\")
                return False
        logger.info(f\"Bot has all required permissions for {project_key}\")
        return True
    except JIRAError as e:
        logger.error(f\"Permission check failed: {e.text}\")
        return False