firefighter-incident 0.0.21__py3-none-any.whl → 0.0.23__py3-none-any.whl

firefighter/jira_app/models.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from django.conf import settings
 from django.db import models
 from django_stubs_ext.db.models import TypedModelMeta
 
@@ -59,3 +60,52 @@ class JiraIssue(models.Model):
 
     def __str__(self) -> str:
         return f"{self.key}: {self.summary}"
+
+
+class JiraPostMortem(models.Model):
+    """Jira Post-mortem linked to an Incident."""
+
+    incident = models.OneToOneField(
+        "incidents.Incident",
+        on_delete=models.CASCADE,
+        related_name="jira_postmortem_for",
+        help_text="Incident this post-mortem is for",
+    )
+
+    jira_issue_key = models.CharField(
+        max_length=32,
+        unique=True,
+        help_text="Jira issue key (e.g., INCIDENT-123)",
+    )
+
+    jira_issue_id = models.CharField(
+        max_length=32,
+        unique=True,
+        help_text="Jira issue ID",
+    )
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    created_by = models.ForeignKey(
+        User,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="jira_postmortems_created",
+    )
+
+    class Meta(TypedModelMeta):
+        db_table = "jira_postmortem"
+        verbose_name = "Jira Post-mortem"
+        verbose_name_plural = "Jira Post-mortems"
+
+    def __str__(self) -> str:
+        return (
+            f"Jira Post-mortem {self.jira_issue_key} for incident #{self.incident.id}"
+        )
+
+    @property
+    def issue_url(self) -> str:
+        """Return Jira issue URL."""
+        return f"{settings.RAID_JIRA_API_URL}/browse/{self.jira_issue_key}"

firefighter/jira_app/service_postmortem.py

@@ -0,0 +1,292 @@
+"""Service for creating and managing Jira post-mortems."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING
+
+from django.conf import settings
+from django.template.loader import render_to_string
+
+from firefighter.jira_app.client import (
+    JiraClient,
+    JiraUserDatabaseError,
+    JiraUserNotFoundError,
+)
+from firefighter.jira_app.models import JiraPostMortem
+
+if TYPE_CHECKING:
+    from firefighter.incidents.models.incident import Incident
+    from firefighter.incidents.models.user import User
+
+logger = logging.getLogger(__name__)
+
+
+class JiraPostMortemService:
+    """Service for creating and managing Jira post-mortems."""
+
+    def __init__(self) -> None:
+        self.client = JiraClient()
+        self.project_key = getattr(settings, "JIRA_POSTMORTEM_PROJECT_KEY", "INCIDENT")
+        self.issue_type = getattr(settings, "JIRA_POSTMORTEM_ISSUE_TYPE", "Post-mortem")
+        self.field_ids = getattr(
+            settings,
+            "JIRA_POSTMORTEM_FIELDS",
+            {
+                "incident_summary": "customfield_12699",
+                "timeline": "customfield_12700",
+                "root_causes": "customfield_12701",
+                "impact": "customfield_12702",
+                "mitigation_actions": "customfield_12703",
+                "incident_category": "customfield_12369",
+            },
+        )
+
+    def create_postmortem_for_incident(
+        self,
+        incident: Incident,
+        created_by: User | None = None,
+    ) -> JiraPostMortem:
+        """Create a Jira post-mortem for an incident.
+
+        Args:
+            incident: Incident to create post-mortem for
+            created_by: User creating the post-mortem
+
+        Returns:
+            JiraPostMortem instance
+
+        Raises:
+            ValueError: If incident already has a Jira post-mortem
+            JiraAPIError: If Jira API call fails
+        """
+        if hasattr(incident, "jira_postmortem_for"):
+            error_msg = f"Incident #{incident.id} already has a Jira post-mortem"
+            raise ValueError(error_msg)
+
+        logger.info(f"Creating Jira post-mortem for incident #{incident.id}")
+
+        # Prefetch incident updates and jira_ticket for timeline and parent link
+        from firefighter.incidents.models.incident import Incident  # noqa: PLC0415
+
+        incident = (
+            Incident.objects.select_related("priority", "environment", "jira_ticket")
+            .prefetch_related("incidentupdate_set")
+            .get(pk=incident.pk)
+        )
+
+        # Generate content from templates
+        fields = self._generate_issue_fields(incident)
+
+        # Get parent issue key from RAID Jira ticket if available
+        parent_issue_key = None
+        if hasattr(incident, "jira_ticket") and incident.jira_ticket:
+            parent_issue_key = incident.jira_ticket.key
+
+        # Create Jira issue with optional parent link
+        jira_issue = self.client.create_postmortem_issue(
+            project_key=self.project_key,
+            issue_type=self.issue_type,
+            fields=fields,
+            parent_issue_key=parent_issue_key,
+        )
+
+        # Assign to incident commander if available
+        commander = (
+            incident.roles_set.select_related("user__jira_user", "role_type")
+            .filter(role_type__slug="commander")
+            .first()
+        )
+        if commander:
+            jira_user = getattr(commander.user, "jira_user", None)
+            if jira_user is None:
+                try:
+                    jira_user = self.client.get_jira_user_from_user(commander.user)
+                except (JiraUserNotFoundError, JiraUserDatabaseError) as exc:
+                    logger.warning(
+                        "Unable to fetch Jira user for commander %s: %s",
+                        commander.user_id,
+                        exc,
+                    )
+            if jira_user is not None:
+                assigned = self.client.assign_issue(
+                    issue_key=jira_issue["key"],
+                    account_id=jira_user.id,
+                )
+                if assigned:
+                    logger.info(
+                        "Assigned post-mortem %s to commander %s",
+                        jira_issue["key"],
+                        commander.user.username,
+                    )
+
+        # Create JiraPostMortem record
+        jira_postmortem = JiraPostMortem.objects.create(
+            incident=incident,
+            jira_issue_key=jira_issue["key"],
+            jira_issue_id=jira_issue["id"],
+            created_by=created_by,
+        )
+
+        logger.info(
+            f"Created Jira post-mortem {jira_postmortem.jira_issue_key} "
+            f"for incident #{incident.id}"
+        )
+
+        return jira_postmortem
+
+    def _generate_issue_fields(
+        self, incident: Incident
+    ) -> dict[str, str | dict[str, str] | list[dict[str, str]]]:
+        """Generate Jira issue fields from incident data.
+
+        Args:
+            incident: Incident to generate fields for
+
+        Returns:
+            Dictionary of Jira field IDs to values
+        """
+        # Generate summary (standard field)
+        env = getattr(settings, "ENV", "dev")
+        topic_prefix = "" if env in {"support", "prod"} else f"[IGNORE - TEST {env}] "
+        summary = (
+            f"{topic_prefix}#{incident.slack_channel_name} "
+            f"({incident.priority.name}) {incident.title}"
+        )
+
+        # Generate content from Django templates (Jira Wiki Markup)
+        context = {
+            "incident": incident,
+            "priority": incident.priority,
+            "created_at": incident.created_at,
+            "components": [],  # No component relationship available
+        }
+
+        incident_summary = render_to_string(
+            "jira/postmortem/incident_summary.txt",
+            context,
+        )
+
+        timeline = render_to_string(
+            "jira/postmortem/timeline.txt",
+            context,
+        )
+
+        impact = render_to_string(
+            "jira/postmortem/impact.txt",
+            context,
+        )
+
+        mitigation_actions = render_to_string(
+            "jira/postmortem/mitigation_actions.txt",
+            context,
+        )
+
+        # Optional: root causes (editable placeholder for manual completion)
+        root_causes = render_to_string(
+            "jira/postmortem/root_causes.txt",
+            context,
+        )
+
+        # Build field mapping
+        fields: dict[str, str | dict[str, str] | list[dict[str, str]]] = {
+            "summary": summary,
+            self.field_ids["incident_summary"]: incident_summary,
+            self.field_ids["timeline"]: timeline,
+            self.field_ids["impact"]: impact,
+            self.field_ids["mitigation_actions"]: mitigation_actions,
+        }
+
+        due_date = self._add_business_days(incident.created_at, 40).date()
+        fields["duedate"] = due_date.isoformat()
+
+        # Add optional fields if not empty
+        if root_causes.strip():
+            fields[self.field_ids["root_causes"]] = root_causes
+
+        # Add incident category if available
+        if incident.incident_category:
+            # Jira select field requires dict with value key
+            category_field_id = self.field_ids["incident_category"]
+            fields[category_field_id] = {"value": incident.incident_category.name}
+
+        # Replicate custom fields from incident ticket to post-mortem
+        self._add_replicated_custom_fields(incident, fields)
+
+        return fields
+
+    def _add_replicated_custom_fields(
+        self,
+        incident: Incident,
+        fields: dict[str, str | dict[str, str] | list[dict[str, str]]],
+    ) -> None:
+        """Replicate custom fields from incident ticket to post-mortem.
+
+        Replicates the following fields from the incident ticket:
+        - Priority (customfield_11064)
+        - Affected environments (customfield_11049)
+        - Zoho desk ticket (customfield_10896)
+        - Zendesk ticket (customfield_10895)
+        - Seller Contract ID (customfield_10908)
+        - Platform (customfield_10201)
+        - Business Impact (customfield_10936)
+
+        Args:
+            incident: Incident to extract fields from
+            fields: Dictionary to add fields to (modified in place)
+        """
+        custom_fields = incident.custom_fields or {}
+
+        # Priority - customfield_11064 (option field)
+        if incident.priority:
+            priority_value = str(incident.priority.value)
+            fields["customfield_11064"] = {"value": priority_value}
+
+        # Affected environments - customfield_11049 (array field)
+        environments = custom_fields.get("environments", [])
+        if environments:
+            fields["customfield_11049"] = [{"value": env} for env in environments]
+
+        # Zendesk ticket - customfield_10895 (string field)
+        zendesk_ticket_id = custom_fields.get("zendesk_ticket_id")
+        if zendesk_ticket_id:
+            fields["customfield_10895"] = str(zendesk_ticket_id)
+
+        # Zoho desk ticket - customfield_10896 (string field)
+        zoho_desk_ticket_id = custom_fields.get("zoho_desk_ticket_id")
+        if zoho_desk_ticket_id:
+            fields["customfield_10896"] = str(zoho_desk_ticket_id)
+
+        # Seller Contract ID - customfield_10908 (string field)
+        seller_contract_id = custom_fields.get("seller_contract_id")
+        if seller_contract_id:
+            fields["customfield_10908"] = str(seller_contract_id)
+
+        # Platform - customfield_10201 (option field)
+        platform = custom_fields.get("platform")
+        if platform:
+            # Remove "platform-" prefix if present
+            platform_value = platform.replace("platform-", "") if isinstance(platform, str) else platform
+            fields["customfield_10201"] = {"value": platform_value}
+
+        # Business Impact - customfield_10936 (option field)
+        # Business impact is stored in the Jira ticket, not in custom_fields
+        if hasattr(incident, "jira_ticket") and incident.jira_ticket:
+            business_impact = incident.jira_ticket.business_impact
+            if business_impact and business_impact not in {"", "N/A"}:
+                fields["customfield_10936"] = {"value": business_impact}
+
+    @staticmethod
+    def _add_business_days(start: datetime, days: int) -> datetime:
+        current = start
+        added = 0
+        while added < days:
+            current += timedelta(days=1)
+            if current.weekday() < 5:
+                added += 1
+        return current
+
+
+# Singleton instance
+jira_postmortem_service = JiraPostMortemService()

firefighter/jira_app/signals/__init__.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from firefighter.jira_app.signals.incident_key_events_updated import (
+    sync_key_events_to_jira_postmortem,
+)
+from firefighter.jira_app.signals.postmortem_created import (
+    postmortem_created_handler,
+)
+
+__all__ = ["postmortem_created_handler", "sync_key_events_to_jira_postmortem"]

firefighter/jira_app/signals/incident_key_events_updated.py

@@ -0,0 +1,88 @@
+"""Signal handlers for incident key events updates to sync with Jira post-mortem."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from django.conf import settings
+from django.dispatch import receiver
+from django.template.loader import render_to_string
+
+from firefighter.incidents.models.incident import Incident as IncidentModel
+from firefighter.incidents.signals import incident_key_events_updated
+from firefighter.jira_app.client import JiraClient
+from firefighter.jira_app.service_postmortem import JiraPostMortemService
+
+if TYPE_CHECKING:
+    from firefighter.incidents.models.incident import Incident
+
+logger = logging.getLogger(__name__)
+
+
+@receiver(signal=incident_key_events_updated)
+def sync_key_events_to_jira_postmortem(
+    sender: Any, incident: Incident, **kwargs: dict[str, Any]
+) -> None:
+    """Update Jira post-mortem timeline when key events are updated.
+
+    This handler is triggered when incident key events are updated via the web UI
+    or Slack, and syncs the timeline to the associated Jira post-mortem ticket.
+
+    Args:
+        sender: The sender of the signal
+        incident: The incident whose key events were updated
+        **kwargs: Additional keyword arguments
+    """
+    # Check if Jira post-mortem is enabled
+    if not getattr(settings, "ENABLE_JIRA_POSTMORTEM", False):
+        logger.debug("Jira post-mortem disabled, skipping timeline sync")
+        return
+
+    # Check if incident has a Jira post-mortem
+    if not hasattr(incident, "jira_postmortem_for") or not incident.jira_postmortem_for:
+        logger.debug(f"Incident #{incident.id} has no Jira post-mortem, skipping timeline sync")
+        return
+
+    jira_postmortem = incident.jira_postmortem_for
+    logger.info(
+        f"Syncing key events timeline to Jira post-mortem {jira_postmortem.jira_issue_key} "
+        f"for incident #{incident.id}"
+    )
+
+    try:
+        # Prefetch incident updates for timeline generation
+        incident_refreshed = (
+            IncidentModel.objects.select_related("priority", "environment")
+            .prefetch_related("incidentupdate_set")
+            .get(pk=incident.pk)
+        )
+
+        # Generate updated timeline from template
+        timeline_content = render_to_string(
+            "jira/postmortem/timeline.txt",
+            {"incident": incident_refreshed},
+        )
+
+        # Get the field ID for timeline from service
+        service = JiraPostMortemService()
+        timeline_field_id = service.field_ids.get("timeline")
+
+        if not timeline_field_id:
+            logger.error("Timeline field ID not found in Jira post-mortem service configuration")
+            return
+
+        # Update the Jira ticket
+        client = JiraClient()
+        issue = client.jira.issue(jira_postmortem.jira_issue_key)
+        issue.update(fields={timeline_field_id: timeline_content})
+
+        logger.info(
+            f"Successfully updated timeline in Jira post-mortem {jira_postmortem.jira_issue_key}"
+        )
+
+    except Exception:
+        logger.exception(
+            f"Failed to update timeline in Jira post-mortem {jira_postmortem.jira_issue_key} "
+            f"for incident #{incident.id}"
+        )

firefighter/jira_app/signals/postmortem_created.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Never
+
+from django.apps import apps
+from django.conf import settings
+from django.dispatch.dispatcher import receiver
+
+from firefighter.incidents.enums import IncidentStatus
+from firefighter.incidents.signals import incident_updated
+
+if TYPE_CHECKING:
+    from firefighter.confluence.models import PostMortemManager
+    from firefighter.incidents.models.incident import Incident
+    from firefighter.incidents.models.incident_update import IncidentUpdate
+    from firefighter.jira_app.service_postmortem import JiraPostMortemService
+
+logger = logging.getLogger(__name__)
+
+
+def _get_jira_postmortem_service() -> JiraPostMortemService:
+    """Lazy import to avoid circular dependency."""
+    from firefighter.jira_app.service_postmortem import (  # noqa: PLC0415
+        jira_postmortem_service,
+    )
+
+    return jira_postmortem_service
+
+
+def _get_confluence_postmortem_manager() -> type[PostMortemManager] | None:
+    """Lazy import to avoid circular dependency with Confluence."""
+    if not apps.is_installed("firefighter.confluence"):
+        return None
+    from firefighter.confluence.models import PostMortemManager  # noqa: PLC0415
+
+    return PostMortemManager
+
+
+@receiver(signal=incident_updated)
+def postmortem_created_handler(
+    sender: Any,
+    incident: Incident,
+    incident_update: IncidentUpdate,
+    updated_fields: list[str],
+    **kwargs: Never,
+) -> None:
+    """Handle post-mortem creation when incident reaches MITIGATED status.
+
+    This handler is registered in jira_app to ensure it works independently
+    of Confluence being enabled. It creates post-mortems for both Confluence
+    and Jira based on their respective feature flags.
+    """
+    logger.debug(
+        f"postmortem_created_handler called with sender={sender}, "
+        f"incident_id={incident.id}, status={incident_update.status}, "
+        f"updated_fields={updated_fields}"
+    )
+
+    if not apps.is_installed("firefighter.slack"):
+        logger.error("Slack app is not installed. Skipping.")
+        return
+
+    # Import Slack tasks after apps are loaded
+    from firefighter.slack.tasks.reminder_postmortem import (  # noqa: PLC0415
+        publish_fixed_next_actions,
+        publish_postmortem_reminder,
+    )
+
+    logger.debug(f"Checking sender: sender={sender}, type={type(sender)}")
+    if sender != "update_status":
+        logger.debug(f"Ignoring signal from sender={sender}")
+        return
+
+    logger.debug("Sender is update_status, checking postmortem conditions")
+
+    # Check if we should create post-mortem(s)
+    if (
+        "_status" not in updated_fields
+        or incident_update.status
+        not in {IncidentStatus.MITIGATED, IncidentStatus.POST_MORTEM}
+        or not incident.needs_postmortem
+    ):
+        logger.debug(
+            f"Not creating post-mortem: _status in fields={('_status' in updated_fields)}, "
+            f"status={incident_update.status}, needs_postmortem={incident.needs_postmortem}"
+        )
+        # For P3+ incidents, publish next actions reminder
+        if (
+            "_status" in updated_fields
+            and incident_update.status
+            in {IncidentStatus.MITIGATED, IncidentStatus.POST_MORTEM}
+            and not incident.needs_postmortem
+        ):
+            publish_fixed_next_actions(incident)
+        return
+
+    logger.info(
+        f"Creating post-mortem(s) for incident #{incident.id} "
+        f"(status={incident_update.status}, needs_postmortem={incident.needs_postmortem})"
+    )
+
+    enable_confluence = getattr(settings, "ENABLE_CONFLUENCE", False)
+    enable_jira_postmortem = getattr(settings, "ENABLE_JIRA_POSTMORTEM", False)
+
+    confluence_pm = None
+    jira_pm = None
+
+    # Check and create Confluence post-mortem
+    if enable_confluence:
+        has_confluence = hasattr(incident, "postmortem_for")
+        logger.debug(f"Confluence enabled, has_confluence={has_confluence}")
+        if not has_confluence:
+            confluence_manager = _get_confluence_postmortem_manager()
+            if confluence_manager:
+                logger.info(f"Creating Confluence post-mortem for incident #{incident.id}")
+                try:
+                    confluence_pm = confluence_manager._create_confluence_postmortem(  # noqa: SLF001
+                        incident
+                    )
+                except Exception:
+                    logger.exception(
+                        f"Failed to create Confluence post-mortem for incident #{incident.id}"
+                    )
+        else:
+            logger.debug(f"Confluence post-mortem already exists for incident #{incident.id}")
+
+    # Check and create Jira post-mortem
+    if enable_jira_postmortem:
+        has_jira = hasattr(incident, "jira_postmortem_for")
+        logger.debug(f"Jira post-mortem enabled, has_jira={has_jira}")
+        if not has_jira:
+            logger.info(f"Creating Jira post-mortem for incident #{incident.id}")
+            try:
+                jira_service = _get_jira_postmortem_service()
+                jira_pm = jira_service.create_postmortem_for_incident(incident)
+            except Exception:
+                logger.exception(
+                    f"Failed to create Jira post-mortem for incident #{incident.id}"
+                )
+        else:
+            logger.debug(f"Jira post-mortem already exists for incident #{incident.id}")
+
+    # Send signal if at least one post-mortem was created
+    if confluence_pm or jira_pm:
+        from firefighter.incidents.signals import postmortem_created  # noqa: PLC0415
+
+        logger.info(
+            f"Post-mortem(s) created for incident #{incident.id}: "
+            f"confluence={confluence_pm is not None}, jira={jira_pm is not None}"
+        )
+        postmortem_created.send_robust(sender=__name__, incident=incident)
+
+    # Publish reminder
+    publish_postmortem_reminder(incident)

firefighter/jira_app/templates/jira/postmortem/impact.txt

@@ -0,0 +1,12 @@
+h2. Impact
+
+h3. Affected Systems
+{% if components %}
+{% for component in components %}* {{ component.name }}
+{% endfor %}
+{% else %}_No components recorded._
+{% endif %}
+
+h3. User Impact
+
+*{color:red}_TODO: Describe the impact on users and business._{color}*

firefighter/jira_app/templates/jira/postmortem/incident_summary.txt

@@ -0,0 +1,17 @@
+h2. Incident Summary
+
+*Incident:* [#{{ incident.slack_channel_name }}|{{ incident.slack_channel_url }}]
+*Priority:* {{ incident.priority.name }} (P{{ incident.priority.value }})
+{% if incident.description %}
+
+h3. Description
+
+{{ incident.description }}
+{% endif %}
+{% if components %}
+
+h3. Affected Components
+
+{% for component in components %}* {{ component.name }}
+{% endfor %}
+{% endif %}

firefighter/jira_app/templates/jira/postmortem/mitigation_actions.txt

@@ -0,0 +1,9 @@
+h2. Mitigation Actions
+
+h3. Immediate Actions Taken
+
+*{color:red}_TODO: List the immediate actions taken to mitigate the incident._{color}*
+
+h3. Long-term Actions
+
+*{color:red}_TODO: List the long-term actions to prevent recurrence._{color}*

firefighter/jira_app/templates/jira/postmortem/root_causes.txt

@@ -0,0 +1,12 @@
+h2. Root Causes
+
+*{color:red}_TODO: Analyze and document the root causes of this incident._{color}*
+
+h3. Contributing Factors
+
+* *{color:red}_TODO: Factor 1_{color}*
+* *{color:red}_TODO: Factor 2_{color}*
+
+h3. Why it happened
+
+*{color:red}_TODO: Explain why this incident occurred._{color}*

firefighter/jira_app/templates/jira/postmortem/timeline.txt

@@ -0,0 +1,7 @@
+h2. Timeline
+
+|| Time || Event ||
+| {{ incident.created_at|date:"Y-m-d H:i" }} UTC | Incident created ({{ incident.priority.name }}) |
+{% for update in incident.incidentupdate_set.all|dictsort:"event_ts" %}{% if update.status %}| {{ update.event_ts|date:"Y-m-d H:i" }} UTC | Status changed to: {{ update.status.label }} |
+{% endif %}{% if update.event_type %}| {{ update.event_ts|date:"Y-m-d H:i" }} UTC | Key event: {{ update.event_type|title }}{% if update.message %} - {{ update.message }}{% endif %} |
+{% endif %}{% endfor %}