firefighter-incident 0.0.26__tar.gz → 0.0.27__tar.gz

{firefighter_incident-0.0.26 → firefighter_incident-0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firefighter-incident
-Version: 0.0.26
+Version: 0.0.27
 Summary: Incident Management tool made for Slack using Django
 Project-URL: Repository, https://github.com/ManoManoTech/firefighter-incident
 Project-URL: Documentation, https://manomanotech.github.io/firefighter-incident/latest/

{firefighter_incident-0.0.26 → firefighter_incident-0.0.27}/firefighter/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.26'
-__version_tuple__ = version_tuple = (0, 0, 26)
+__version__ = version = '0.0.27'
+__version_tuple__ = version_tuple = (0, 0, 27)
 
 __commit_id__ = commit_id = None

{firefighter_incident-0.0.26 → firefighter_incident-0.0.27}/firefighter/confluence/models.py

@@ -12,7 +12,6 @@ from django.db import models
 from django.urls import reverse
 from django_filters.filters import AllValuesMultipleFilter
 
-from firefighter.confluence.service import confluence_service
 from firefighter.firefighter.fields_forms_widgets import CustomCheckboxSelectMultiple
 from firefighter.incidents.models.incident import Incident
 from firefighter.incidents.signals import postmortem_created
@@ -87,11 +86,18 @@ class PostMortemManager(models.Manager["PostMortem"]):
 
         return confluence_pm, jira_pm
 
+    @staticmethod
+    def create_confluence_postmortem(incident: Incident) -> PostMortem:
+        """Create Confluence post-mortem (existing logic)."""
+        return PostMortemManager._create_confluence_postmortem(incident)
+
     @staticmethod
     def _create_confluence_postmortem(incident: Incident) -> PostMortem:
         """Create Confluence post-mortem (existing logic)."""
         logger.info("Creating Confluence PostMortem for %s", incident)
 
+        from firefighter.confluence.service import confluence_service
+
         topic_prefix = (
             ""
             if settings.ENV in {"support", "prod"}
@@ -163,6 +169,9 @@ class ConfluencePage(models.Model):
 
     version = models.JSONField(default=dict)  # We need a callable
 
+    class Meta:
+        app_label = "confluence"
+
     def __str__(self) -> str:
         return self.name
 
@@ -176,6 +185,9 @@ class PostMortem(ConfluencePage):
         Incident, on_delete=models.CASCADE, related_name="postmortem_for"
     )
 
+    class Meta:
+        app_label = "confluence"
+
     def __str__(self) -> str:
         return self.name
 
@@ -222,6 +234,9 @@ class Runbook(ConfluencePage):
     service_name = models.CharField(max_length=255)
     service_type = models.CharField(max_length=255)
 
+    class Meta:
+        app_label = "confluence"
+
     def __str__(self) -> str:
         return self.name
 

firefighter_incident-0.0.27/firefighter/incidents/management/__init__.py

@@ -0,0 +1 @@
+# Management commands for incidents app

firefighter_incident-0.0.27/firefighter/incidents/management/commands/__init__.py

@@ -0,0 +1 @@
+# Django management commands

firefighter_incident-0.0.27/firefighter/incidents/management/commands/backdate_incident_mitigated.py

@@ -0,0 +1,94 @@
+"""Django management command to backdate an incident's mitigated_at timestamp for testing."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import Any
+
+from django.core.management.base import BaseCommand, CommandParser
+from django.utils import timezone
+
+from firefighter.incidents.models.incident import Incident
+
+
+class Command(BaseCommand):
+    """Backdate an incident's mitigated_at timestamp for testing post-mortem reminders."""
+
+    help = "Backdate an incident's mitigated_at timestamp by a specified number of days"
+
+    def add_arguments(self, parser: CommandParser) -> None:
+        parser.add_argument(
+            "incident_id",
+            type=int,
+            help="ID of the incident to backdate",
+        )
+        parser.add_argument(
+            "--days",
+            type=int,
+            default=6,
+            help="Number of days to backdate (default: 6, to trigger 5-day reminder)",
+        )
+        parser.add_argument(
+            "--reset",
+            action="store_true",
+            help="Reset mitigated_at to current time instead of backdating",
+        )
+
+    def handle(self, *args: Any, **options: Any) -> None:
+        incident_id = options["incident_id"]
+        days = options["days"]
+        reset = options["reset"]
+
+        try:
+            incident = Incident.objects.get(id=incident_id)
+        except Incident.DoesNotExist:
+            self.stdout.write(
+                self.style.ERROR(f"Incident #{incident_id} does not exist")
+            )
+            return
+
+        if reset:
+            incident.mitigated_at = timezone.now()
+            incident.save(update_fields=["mitigated_at"])
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"✅ Reset mitigated_at for incident #{incident_id} to current time: {incident.mitigated_at}"
+                )
+            )
+        else:
+            old_value = incident.mitigated_at
+            new_value = timezone.now() - timedelta(days=days)
+            incident.mitigated_at = new_value
+            incident.save(update_fields=["mitigated_at"])
+
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"✅ Backdated incident #{incident_id} mitigated_at:"
+                )
+            )
+            self.stdout.write(f"   Old value: {old_value}")
+            self.stdout.write(f"   New value: {new_value}")
+            self.stdout.write(f"   Backdated by {days} days")
+
+        self.stdout.write("\nIncident details:")
+        self.stdout.write(f"   ID: {incident.id}")
+        self.stdout.write(f"   Title: {incident.title}")
+        self.stdout.write(f"   Priority: {incident.priority.name}")
+        self.stdout.write(f"   Status: {incident.status.label}")
+        self.stdout.write(f"   Needs postmortem: {incident.needs_postmortem}")
+        self.stdout.write(f"   Mitigated at: {incident.mitigated_at}")
+
+        if incident.needs_postmortem and days >= 5:
+            self.stdout.write(
+                self.style.WARNING(
+                    "\n⚠️  This incident should now trigger a 5-day reminder!"
+                )
+            )
+            self.stdout.write(
+                "\nTo test the reminder, run:"
+            )
+            self.stdout.write(
+                self.style.NOTICE(
+                    "   pdm run python manage.py test_postmortem_reminders"
+                )
+            )

firefighter_incident-0.0.27/firefighter/incidents/management/commands/test_postmortem_reminders.py

@@ -0,0 +1,113 @@
+"""Django management command to test post-mortem reminders."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import Any
+
+from django.core.management.base import BaseCommand, CommandParser
+from django.utils import timezone
+
+from firefighter.incidents.enums import IncidentStatus
+from firefighter.incidents.models.incident import Incident
+from firefighter.slack.tasks.send_postmortem_reminders import (
+    POSTMORTEM_REMINDER_DAYS,
+    send_postmortem_reminders,
+)
+
+
+class Command(BaseCommand):
+    """Test post-mortem reminders by executing the task manually."""
+
+    help = "Execute the post-mortem reminder task manually for testing"
+
+    def add_arguments(self, parser: CommandParser) -> None:
+        parser.add_argument(
+            "--list-only",
+            action="store_true",
+            help="Only list eligible incidents without sending reminders",
+        )
+
+    def handle(self, *args: Any, **options: Any) -> None:
+        list_only = options["list_only"]
+
+        self.stdout.write(self.style.MIGRATE_HEADING("Post-Mortem Reminder Testing"))
+        self.stdout.write("=" * 70)
+
+        # Calculate cutoff date
+        cutoff_date = timezone.now() - timedelta(days=POSTMORTEM_REMINDER_DAYS)
+
+        self.stdout.write(f"\n⏰ Reminder threshold: {POSTMORTEM_REMINDER_DAYS} days")
+        self.stdout.write(f"📅 Cutoff date: {cutoff_date}")
+        self.stdout.write(f"🕐 Current time: {timezone.now()}\n")
+
+        # Find eligible incidents
+        eligible_incidents = Incident.objects.filter(
+            mitigated_at__lte=cutoff_date,
+            mitigated_at__isnull=False,
+            _status__in=[
+                IncidentStatus.MITIGATED.value,
+                IncidentStatus.POST_MORTEM.value,
+            ],
+            priority__needs_postmortem=True,
+            ignore=False,
+        ).select_related("priority", "environment", "conversation")
+
+        count = eligible_incidents.count()
+        self.stdout.write(f"🔍 Found {count} incident(s) eligible for reminder\n")
+
+        if count == 0:
+            self.stdout.write(
+                self.style.WARNING("⚠️  No incidents found needing reminders")
+            )
+            self.stdout.write("\nTo test, you can backdate an incident with:")
+            self.stdout.write(
+                self.style.NOTICE(
+                    "   pdm run python manage.py backdate_incident_mitigated <incident_id> --days 6"
+                )
+            )
+            return
+
+        # Display eligible incidents
+        for incident in eligible_incidents:
+            days_since_mitigated = (
+                timezone.now() - incident.mitigated_at
+            ).days if incident.mitigated_at else 0
+
+            self.stdout.write(f"  📋 Incident #{incident.id}")
+            self.stdout.write(f"     Title: {incident.title}")
+            self.stdout.write(f"     Priority: {incident.priority.name}")
+            self.stdout.write(f"     Status: {incident.status.label}")
+            self.stdout.write(f"     Mitigated: {incident.mitigated_at}")
+            self.stdout.write(
+                f"     Days since mitigated: {days_since_mitigated} days"
+            )
+            self.stdout.write(f"     Environment: {incident.environment.value}")
+            self.stdout.write(f"     Private: {incident.private}")
+            self.stdout.write("")
+
+        if list_only:
+            self.stdout.write(
+                self.style.SUCCESS(
+                    "✅ List-only mode: No reminders sent"
+                )
+            )
+            self.stdout.write("\nTo send reminders, run without --list-only flag")
+            return
+
+        # Execute the task
+        self.stdout.write("=" * 70)
+        self.stdout.write(
+            self.style.WARNING("🚀 Executing post-mortem reminder task...\n")
+        )
+
+        try:
+            send_postmortem_reminders()
+            self.stdout.write("\n" + "=" * 70)
+            self.stdout.write(
+                self.style.SUCCESS("✅ Task execution completed successfully!")
+            )
+        except Exception as e:
+            self.stdout.write("\n" + "=" * 70)
+            self.stdout.write(self.style.ERROR(f"❌ Task execution failed: {e}"))
+            raise

firefighter_incident-0.0.27/firefighter/incidents/migrations/0030_add_mitigated_at_field.py

@@ -0,0 +1,22 @@
+# Generated by Django 4.2.21 on 2025-12-19 14:02
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("incidents", "0029_add_custom_fields_to_incident"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="incident",
+            name="mitigated_at",
+            field=models.DateTimeField(
+                blank=True,
+                help_text="Timestamp when incident status changed to MITIGATED",
+                null=True,
+            ),
+        ),
+    ]

{firefighter_incident-0.0.26 → firefighter_incident-0.0.27}/firefighter/incidents/models/incident.py

@@ -214,12 +214,8 @@ class Incident(models.Model):
         on_delete=models.PROTECT,
         help_text="Priority",
     )
-    incident_category = models.ForeignKey(
-        IncidentCategory, on_delete=models.PROTECT
-    )
-    environment = models.ForeignKey(
-        Environment, on_delete=models.PROTECT
-    )
+    incident_category = models.ForeignKey(IncidentCategory, on_delete=models.PROTECT)
+    environment = models.ForeignKey(Environment, on_delete=models.PROTECT)
     created_by = models.ForeignKey(
         User,
         on_delete=models.PROTECT,
@@ -229,6 +225,11 @@ class Incident(models.Model):
 
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
+    mitigated_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="Timestamp when incident status changed to MITIGATED",
+    )
     closed_at = models.DateTimeField(
         null=True, blank=True
     )  # XXX-ZOR make this an event
@@ -380,6 +381,36 @@ class Incident(models.Model):
                         f"Incident is not in PostMortem status, and needs one because of its priority and environment ({self.priority.name}/{self.environment.value}).",
                     )
                 )
+            # If a Jira post-mortem exists, ensure it is in the expected "Ready" status
+            if hasattr(self, "jira_postmortem_for"):
+                try:
+                    from firefighter.jira_app.service_postmortem import (  # noqa: PLC0415
+                        jira_postmortem_service,
+                    )
+
+                    is_ready, current_status = (
+                        jira_postmortem_service.is_postmortem_ready(
+                            self.jira_postmortem_for
+                        )
+                    )
+                    if not is_ready:
+                        cant_closed_reasons.append(
+                            (
+                                "POSTMORTEM_NOT_READY",
+                                f"Jira post-mortem {self.jira_postmortem_for.jira_issue_key} is not Ready (current status: {current_status}).",
+                            )
+                        )
+                except Exception:  # pragma: no cover - defensive guard
+                    logger.exception(
+                        "Failed to verify Jira post-mortem status for incident #%s",
+                        self.id,
+                    )
+                    cant_closed_reasons.append(
+                        (
+                            "POSTMORTEM_STATUS_UNKNOWN",
+                            "Could not verify Jira post-mortem status. Please check it in Jira.",
+                        )
+                    )
         elif self.status.value < IncidentStatus.MITIGATED:
             cant_closed_reasons.append(
                 (
@@ -606,7 +637,9 @@ class Incident(models.Model):
 
         _update_incident_field(self, "_status", status, updated_fields)
         _update_incident_field(self, "priority_id", priority_id, updated_fields)
-        _update_incident_field(self, "incident_category_id", incident_category_id, updated_fields)
+        _update_incident_field(
+            self, "incident_category_id", incident_category_id, updated_fields
+        )
         _update_incident_field(self, "title", title, updated_fields)
         _update_incident_field(self, "description", description, updated_fields)
         _update_incident_field(self, "environment_id", environment_id, updated_fields)
@@ -706,7 +739,9 @@ class IncidentFilterSet(django_filters.FilterSet):
         widget=CustomCheckboxSelectMultiple,
     )
     group = ModelMultipleChoiceFilter(
-        queryset=Group.objects.all(), field_name="incident_category__group_id", label="Group"
+        queryset=Group.objects.all(),
+        field_name="incident_category__group_id",
+        label="Group",
     )
     incident_category = ModelMultipleChoiceFilter(
         queryset=incident_category_filter_choices_queryset,

{firefighter_incident-0.0.26 → firefighter_incident-0.0.27}/firefighter/jira_app/service_postmortem.py

@@ -30,6 +30,9 @@ class JiraPostMortemService:
         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.ready_status_name = getattr(
+            settings, "JIRA_POSTMORTEM_READY_STATUS", "Ready"
+        )
         self.field_ids = getattr(
             settings,
             "JIRA_POSTMORTEM_FIELDS",
@@ -136,6 +139,16 @@ class JiraPostMortemService:
 
         return jira_postmortem
 
+    def is_postmortem_ready(self, jira_postmortem: JiraPostMortem) -> tuple[bool, str]:
+        """Check if the Jira post-mortem issue is in the Ready status.
+
+        Returns:
+            Tuple of (is_ready, current_status_name)
+        """
+        issue = self.client.jira.issue(jira_postmortem.jira_issue_id)
+        status_name: str = getattr(issue.fields.status, "name", "")
+        return status_name == self.ready_status_name, status_name
+
     def _generate_issue_fields(
         self, incident: Incident
     ) -> dict[str, str | dict[str, str] | list[dict[str, str]]]:

firefighter_incident-0.0.27/firefighter/jira_app/signals/postmortem_created.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import importlib
+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 django.utils import timezone
+
+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."""
+    module = importlib.import_module("firefighter.jira_app.service_postmortem")
+    return module.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
+    module = importlib.import_module("firefighter.confluence.models")
+    return module.PostMortemManager
+
+
+def _update_mitigated_at_timestamp(
+    incident: Incident, incident_update: IncidentUpdate, updated_fields: list[str]
+) -> None:
+    """Update mitigated_at timestamp when incident status changes to MITIGATED."""
+    if (
+        "_status" in updated_fields
+        and incident_update.status == IncidentStatus.MITIGATED
+        and incident.mitigated_at is None
+    ):
+        incident.mitigated_at = timezone.now()
+        incident.save(update_fields=["mitigated_at"])
+        logger.info(f"Set mitigated_at timestamp for incident #{incident.id}")
+
+
+def _create_confluence_postmortem(incident: Incident) -> Any | None:
+    """Create Confluence post-mortem if needed."""
+    has_confluence = hasattr(incident, "postmortem_for")
+    logger.debug(f"Confluence enabled, has_confluence={has_confluence}")
+
+    if has_confluence:
+        logger.debug(f"Confluence post-mortem already exists for incident #{incident.id}")
+        return None
+
+    confluence_manager = _get_confluence_postmortem_manager()
+    if not confluence_manager:
+        return None
+
+    logger.info(f"Creating Confluence post-mortem for incident #{incident.id}")
+    try:
+        # Use the public API specifically for Confluence creation
+        return confluence_manager.create_confluence_postmortem(incident)
+    except Exception:
+        logger.exception(
+            f"Failed to create Confluence post-mortem for incident #{incident.id}"
+        )
+        return None
+
+
+def _create_jira_postmortem(incident: Incident) -> Any | None:
+    """Create Jira post-mortem if needed."""
+    has_jira = hasattr(incident, "jira_postmortem_for")
+    logger.debug(f"Jira post-mortem enabled, has_jira={has_jira}")
+
+    if has_jira:
+        logger.debug(f"Jira post-mortem already exists for incident #{incident.id}")
+        return None
+
+    logger.info(f"Creating Jira post-mortem for incident #{incident.id}")
+    try:
+        jira_service = _get_jira_postmortem_service()
+        return jira_service.create_postmortem_for_incident(incident)
+    except Exception:
+        logger.exception(
+            f"Failed to create Jira post-mortem for incident #{incident.id}"
+        )
+        return None
+
+
+def _publish_postmortem_announcement(incident: Incident) -> None:
+    """Publish post-mortem creation announcement to #critical-incidents."""
+    # Dynamic imports to avoid circular dependencies
+    slack_messages = importlib.import_module("firefighter.slack.messages.slack_messages")
+    slack_models = importlib.import_module("firefighter.slack.models.conversation")
+    slack_rules = importlib.import_module("firefighter.slack.rules")
+
+    announcement_class = slack_messages.SlackMessageIncidentPostMortemCreatedAnnouncement
+    conversation_class = slack_models.Conversation
+    should_publish_pm_in_general_channel = slack_rules.should_publish_pm_in_general_channel
+
+    if not should_publish_pm_in_general_channel(incident):
+        return
+
+    tech_incidents_conversation = conversation_class.objects.get_or_none(
+        tag="tech_incidents"
+    )
+    if tech_incidents_conversation:
+        announcement = announcement_class(incident)
+        tech_incidents_conversation.send_message_and_save(announcement)
+        logger.info(
+            f"Post-mortem creation announced in tech_incidents for incident #{incident.id}"
+        )
+    else:
+        logger.warning(
+            "Could not find tech_incidents conversation! Is there a channel with tag tech_incidents?"
+        )
+
+
+@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
+    slack_tasks = importlib.import_module("firefighter.slack.tasks.reminder_postmortem")
+    publish_fixed_next_actions = slack_tasks.publish_fixed_next_actions
+    publish_postmortem_reminder = slack_tasks.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")
+
+    # Update mitigated_at timestamp
+    _update_mitigated_at_timestamp(incident, incident_update, updated_fields)
+
+    # 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
+
+    # Create Confluence post-mortem if enabled
+    if enable_confluence:
+        confluence_pm = _create_confluence_postmortem(incident)
+
+    # Create Jira post-mortem if enabled
+    if enable_jira_postmortem:
+        jira_pm = _create_jira_postmortem(incident)
+
+    # Send signal and announcements if at least one post-mortem was created
+    if confluence_pm or jira_pm:
+        signals_module = importlib.import_module("firefighter.incidents.signals")
+        postmortem_created = signals_module.postmortem_created
+
+        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_postmortem_announcement(incident)
+
+    # Publish reminder
+    publish_postmortem_reminder(incident)