Управление инцидентами

<?php

declare(strict_types=1);

namespace App\Incident;

enum Severity: string
{
    case Sev1 = 'SEV1';
    case Sev2 = 'SEV2';
    case Sev3 = 'SEV3';
    case Sev4 = 'SEV4';

    public function maxResponseMinutes(): int
    {
        return match ($this) {
            self::Sev1 => 5,
            self::Sev2 => 15,
            self::Sev3 => 60,
            self::Sev4 => 480,
        };
    }

    public function requiresPageOut(): bool
    {
        return match ($this) {
            self::Sev1, self::Sev2 => true,
            self::Sev3, self::Sev4 => false,
        };
    }
}

enum IncidentStatus: string
{
    case Detected = 'detected';
    case Triaged = 'triaged';
    case Investigating = 'investigating';
    case Mitigated = 'mitigated';
    case Resolved = 'resolved';
    case PostmortemPending = 'postmortem_pending';
    case Closed = 'closed';
}

final class Incident
{
    /** @var array<TimelineEntry> */
    private array $timeline = [];
    private IncidentStatus $status;

    public function __construct(
        public readonly string $id,
        public readonly string $title,
        public readonly Severity $severity,
        public readonly \DateTimeImmutable $detectedAt,
        public readonly string $detectedBy,
        private ?string $incidentCommander = null,
    ) {
        $this->status = IncidentStatus::Detected;
        $this->addTimelineEntry('Incident detected', $detectedBy);
    }

    public function assignCommander(string $commander): void
    {
        $this->incidentCommander = $commander;
        $this->addTimelineEntry("Incident Commander assigned: {$commander}", 'system');
    }

    public function updateStatus(IncidentStatus $status, string $updatedBy, string $note = ''): void
    {
        $previousStatus = $this->status;
        $this->status = $status;

        $message = "Status changed: {$previousStatus->value} → {$status->value}";
        if ($note !== '') {
            $message .= " — {$note}";
        }

        $this->addTimelineEntry($message, $updatedBy);
    }

    public function getStatus(): IncidentStatus
    {
        return $this->status;
    }

    /**
     * Calculate time from detection to mitigation.
     */
    public function getTimeToMitigate(): ?int
    {
        $mitigatedEntry = null;

        foreach ($this->timeline as $entry) {
            if (str_contains($entry->message, IncidentStatus::Mitigated->value)) {
                $mitigatedEntry = $entry;
                break;
            }
        }

        if ($mitigatedEntry === null) {
            return null;
        }

        return $mitigatedEntry->timestamp->getTimestamp() - $this->detectedAt->getTimestamp();
    }

    /**
     * Check if response time exceeds SLA.
     */
    public function isResponseOverdue(): bool
    {
        if ($this->status !== IncidentStatus::Detected) {
            return false;
        }

        $elapsedMinutes = (time() - $this->detectedAt->getTimestamp()) / 60;

        return $elapsedMinutes > $this->severity->maxResponseMinutes();
    }

    /** @return array<TimelineEntry> */
    public function getTimeline(): array
    {
        return $this->timeline;
    }

    private function addTimelineEntry(string $message, string $author): void
    {
        $this->timeline[] = new TimelineEntry(
            timestamp: new \DateTimeImmutable(),
            message: $message,
            author: $author,
        );
    }
}

final readonly class TimelineEntry
{
    public function __construct(
        public \DateTimeImmutable $timestamp,
        public string $message,
        public string $author,
    ) {}
}

package incident

import (
	"fmt"
	"strings"
	"sync"
	"time"
)

// Severity represents incident severity levels.
type Severity int

const (
	Sev1 Severity = iota + 1
	Sev2
	Sev3
	Sev4
)

// MaxResponseMinutes returns the max allowed response time.
func (s Severity) MaxResponseMinutes() int {
	switch s {
	case Sev1:
		return 5
	case Sev2:
		return 15
	case Sev3:
		return 60
	default:
		return 480
	}
}

// RequiresPageOut returns true if the severity requires paging.
func (s Severity) RequiresPageOut() bool {
	return s == Sev1 || s == Sev2
}

func (s Severity) String() string {
	return fmt.Sprintf("SEV%d", s)
}

// Status represents incident lifecycle status.
type Status string

const (
	StatusDetected         Status = "detected"
	StatusTriaged          Status = "triaged"
	StatusInvestigating    Status = "investigating"
	StatusMitigated        Status = "mitigated"
	StatusResolved         Status = "resolved"
	StatusPostmortemPending Status = "postmortem_pending"
	StatusClosed           Status = "closed"
)

// TimelineEntry records a point in the incident timeline.
type TimelineEntry struct {
	Timestamp time.Time
	Message   string
	Author    string
}

// Incident tracks an active or resolved incident.
type Incident struct {
	mu                sync.Mutex
	ID                string
	Title             string
	Sev               Severity
	DetectedAt        time.Time
	DetectedBy        string
	IncidentCommander string
	status            Status
	timeline          []TimelineEntry
}

// NewIncident creates a new incident in detected state.
func NewIncident(id, title string, sev Severity, detectedBy string) *Incident {
	inc := &Incident{
		ID:         id,
		Title:      title,
		Sev:        sev,
		DetectedAt: time.Now(),
		DetectedBy: detectedBy,
		status:     StatusDetected,
	}
	inc.addEntry("Incident detected", detectedBy)
	return inc
}

// AssignCommander assigns an incident commander.
func (inc *Incident) AssignCommander(commander string) {
	inc.mu.Lock()
	defer inc.mu.Unlock()
	inc.IncidentCommander = commander
	inc.addEntry(fmt.Sprintf("Incident Commander assigned: %s", commander), "system")
}

// UpdateStatus transitions the incident status.
func (inc *Incident) UpdateStatus(status Status, updatedBy, note string) {
	inc.mu.Lock()
	defer inc.mu.Unlock()
	prev := inc.status
	inc.status = status
	msg := fmt.Sprintf("Status changed: %s -> %s", prev, status)
	if note != "" {
		msg += " -- " + note
	}
	inc.addEntry(msg, updatedBy)
}

// Status returns the current status.
func (inc *Incident) Status() Status {
	inc.mu.Lock()
	defer inc.mu.Unlock()
	return inc.status
}

// TimeToMitigate returns seconds from detection to mitigation, or -1.
func (inc *Incident) TimeToMitigate() int {
	inc.mu.Lock()
	defer inc.mu.Unlock()
	for _, e := range inc.timeline {
		if strings.Contains(e.Message, string(StatusMitigated)) {
			return int(e.Timestamp.Sub(inc.DetectedAt).Seconds())
		}
	}
	return -1
}

// IsResponseOverdue checks if the response time exceeds the SLA.
func (inc *Incident) IsResponseOverdue() bool {
	inc.mu.Lock()
	defer inc.mu.Unlock()
	if inc.status != StatusDetected {
		return false
	}
	elapsed := time.Since(inc.DetectedAt).Minutes()
	return elapsed > float64(inc.Sev.MaxResponseMinutes())
}

func (inc *Incident) addEntry(message, author string) {
	inc.timeline = append(inc.timeline, TimelineEntry{
		Timestamp: time.Now(),
		Message:   message,
		Author:    author,
	})
}

namespace App.Incident;

// Severity classifies incident impact.
public enum Severity
{
    Sev1 = 1,
    Sev2,
    Sev3,
    Sev4,
}

public static class SeverityExtensions
{
    // Max allowed response time for the severity.
    public static int MaxResponseMinutes(this Severity severity) => severity switch
    {
        Severity.Sev1 => 5,
        Severity.Sev2 => 15,
        Severity.Sev3 => 60,
        Severity.Sev4 => 480,
        _ => throw new ArgumentOutOfRangeException(nameof(severity), severity, "Unknown severity"),
    };

    // Whether the severity pages the on-call engineer.
    public static bool RequiresPageOut(this Severity severity) =>
        severity is Severity.Sev1 or Severity.Sev2;
}

// IncidentStatus tracks the incident lifecycle.
public enum IncidentStatus
{
    Detected,
    Triaged,
    Investigating,
    Mitigated,
    Resolved,
    PostmortemPending,
    Closed,
}

// TimelineEntry records a point in the incident timeline.
public sealed record TimelineEntry(DateTimeOffset Timestamp, string Message, string Author);

// Incident tracks an active or resolved incident.
public sealed class Incident
{
    private readonly List<TimelineEntry> _timeline = [];
    private readonly object _gate = new();

    public Incident(
        string id,
        string title,
        Severity severity,
        string detectedBy,
        string? incidentCommander = null)
    {
        Id = id;
        Title = title;
        Severity = severity;
        DetectedAt = DateTimeOffset.UtcNow;
        DetectedBy = detectedBy;
        IncidentCommander = incidentCommander;
        Status = IncidentStatus.Detected;

        AddTimelineEntry("Incident detected", detectedBy);
    }

    public string Id { get; }

    public string Title { get; }

    public Severity Severity { get; }

    public DateTimeOffset DetectedAt { get; }

    public string DetectedBy { get; }

    public string? IncidentCommander { get; private set; }

    public IncidentStatus Status { get; private set; }

    public IReadOnlyList<TimelineEntry> Timeline
    {
        get
        {
            lock (_gate)
            {
                return _timeline.ToArray();
            }
        }
    }

    public void AssignCommander(string commander)
    {
        lock (_gate)
        {
            IncidentCommander = commander;
            AddTimelineEntry($"Incident Commander assigned: {commander}", "system");
        }
    }

    public void UpdateStatus(IncidentStatus status, string updatedBy, string note = "")
    {
        lock (_gate)
        {
            var previousStatus = Status;
            Status = status;

            var message = $"Status changed: {previousStatus} -> {status}";

            if (note.Length > 0)
            {
                message += $" -- {note}";
            }

            AddTimelineEntry(message, updatedBy);
        }
    }

    // Time from detection to mitigation, or null while not mitigated.
    public TimeSpan? GetTimeToMitigate()
    {
        lock (_gate)
        {
            var mitigatedEntry = _timeline.FirstOrDefault(entry =>
                entry.Message.Contains(nameof(IncidentStatus.Mitigated), StringComparison.Ordinal));

            return mitigatedEntry is null ? null : mitigatedEntry.Timestamp - DetectedAt;
        }
    }

    // Whether the response time already exceeds the severity SLA.
    public bool IsResponseOverdue()
    {
        lock (_gate)
        {
            if (Status != IncidentStatus.Detected)
            {
                return false;
            }

            return (DateTimeOffset.UtcNow - DetectedAt).TotalMinutes > Severity.MaxResponseMinutes();
        }
    }

    private void AddTimelineEntry(string message, string author) =>
        _timeline.Add(new TimelineEntry(DateTimeOffset.UtcNow, message, author));
}

import threading
from dataclasses import dataclass
from datetime import UTC, datetime, timedelta
from enum import Enum, StrEnum

class Severity(Enum):
    """Classifies incident impact."""

    SEV1 = 1
    SEV2 = 2
    SEV3 = 3
    SEV4 = 4

    @property
    def max_response_minutes(self) -> int:
        """Max allowed response time for the severity."""
        return {
            Severity.SEV1: 5,
            Severity.SEV2: 15,
            Severity.SEV3: 60,
            Severity.SEV4: 480,
        }[self]

    @property
    def requires_page_out(self) -> bool:
        """Whether the severity pages the on-call engineer."""
        return self in (Severity.SEV1, Severity.SEV2)

class IncidentStatus(StrEnum):
    """Tracks the incident lifecycle."""

    DETECTED = "detected"
    TRIAGED = "triaged"
    INVESTIGATING = "investigating"
    MITIGATED = "mitigated"
    RESOLVED = "resolved"
    POSTMORTEM_PENDING = "postmortem_pending"
    CLOSED = "closed"

@dataclass(frozen=True, slots=True)
class TimelineEntry:
    """A single point in the incident timeline."""

    timestamp: datetime
    message: str
    author: str

class Incident:
    """Tracks an active or resolved incident."""

    def __init__(
        self,
        incident_id: str,
        title: str,
        severity: Severity,
        detected_by: str,
        incident_commander: str | None = None,
    ) -> None:
        self.id = incident_id
        self.title = title
        self.severity = severity
        self.detected_at = datetime.now(UTC)
        self.detected_by = detected_by
        self.incident_commander = incident_commander
        self._status = IncidentStatus.DETECTED
        self._timeline: list[TimelineEntry] = []
        self._lock = threading.Lock()

        self._add_entry("Incident detected", detected_by)

    @property
    def status(self) -> IncidentStatus:
        with self._lock:
            return self._status

    @property
    def timeline(self) -> tuple[TimelineEntry, ...]:
        with self._lock:
            return tuple(self._timeline)

    def assign_commander(self, commander: str) -> None:
        with self._lock:
            self.incident_commander = commander
            self._add_entry(f"Incident Commander assigned: {commander}", "system")

    def update_status(self, status: IncidentStatus, updated_by: str, note: str = "") -> None:
        with self._lock:
            previous_status = self._status
            self._status = status

            message = f"Status changed: {previous_status} -> {status}"

            if note:
                message += f" -- {note}"

            self._add_entry(message, updated_by)

    def time_to_mitigate(self) -> timedelta | None:
        """Time from detection to mitigation, or None while not mitigated."""
        with self._lock:
            for entry in self._timeline:
                # StrEnum members compare as plain strings, so substring search works
                if IncidentStatus.MITIGATED in entry.message:
                    return entry.timestamp - self.detected_at

        return None

    def is_response_overdue(self) -> bool:
        """Whether the response time already exceeds the severity SLA."""
        with self._lock:
            if self._status is not IncidentStatus.DETECTED:
                return False

            elapsed_minutes = (datetime.now(UTC) - self.detected_at).total_seconds() / 60

            return elapsed_minutes > self.severity.max_response_minutes

    def _add_entry(self, message: str, author: str) -> None:
        # Callers hold the lock; __init__ runs before the object is shared
        self._timeline.append(TimelineEntry(datetime.now(UTC), message, author))

<?php

declare(strict_types=1);

namespace App\Incident;

final readonly class IncidentMetrics
{
    /**
     * @param array<Incident> $incidents Resolved incidents for the period
     * @return array{mttr_hours: float, mttm_minutes: float, count: int, by_severity: array}
     */
    public function calculate(array $incidents): array
    {
        if (empty($incidents)) {
            return [
                'mttr_hours' => 0,
                'mttm_minutes' => 0,
                'count' => 0,
                'by_severity' => [],
            ];
        }

        $totalMitigationSeconds = 0;
        $mitigatedCount = 0;
        $bySeverity = [];

        foreach ($incidents as $incident) {
            $ttm = $incident->getTimeToMitigate();

            if ($ttm !== null) {
                $totalMitigationSeconds += $ttm;
                $mitigatedCount++;
            }

            $sev = $incident->severity->value;
            $bySeverity[$sev] ??= 0;
            $bySeverity[$sev]++;
        }

        return [
            'mttr_hours' => 0, // Requires resolution timestamp
            'mttm_minutes' => $mitigatedCount > 0
                ? round($totalMitigationSeconds / $mitigatedCount / 60, 1)
                : 0,
            'count' => count($incidents),
            'by_severity' => $bySeverity,
        ];
    }
}

package incident

// Metrics computes aggregate incident metrics.
type Metrics struct{}

// MetricsResult holds computed incident metrics.
type MetricsResult struct {
	MTTRHours    float64        `json:"mttr_hours"`
	MTTMMinutes  float64        `json:"mttm_minutes"`
	Count        int            `json:"count"`
	BySeverity   map[string]int `json:"by_severity"`
}

// Calculate computes metrics for a set of resolved incidents.
func (m *Metrics) Calculate(incidents []*Incident) MetricsResult {
	if len(incidents) == 0 {
		return MetricsResult{BySeverity: map[string]int{}}
	}

	var totalMitigationSec int
	mitigatedCount := 0
	bySev := make(map[string]int)

	for _, inc := range incidents {
		ttm := inc.TimeToMitigate()
		if ttm >= 0 {
			totalMitigationSec += ttm
			mitigatedCount++
		}
		bySev[inc.Sev.String()]++
	}

	var mttm float64
	if mitigatedCount > 0 {
		mttm = float64(totalMitigationSec) / float64(mitigatedCount) / 60.0
	}

	return MetricsResult{
		MTTMMinutes: mttm,
		Count:       len(incidents),
		BySeverity:  bySev,
	}
}

namespace App.Incident;

// Aggregate incident metrics for a reporting period.
public readonly record struct MetricsResult(
    double MttrHours,
    double MttmMinutes,
    int Count,
    IReadOnlyDictionary<Severity, int> BySeverity);

public sealed class IncidentMetrics
{
    // Compute metrics for a set of resolved incidents.
    public MetricsResult Calculate(IReadOnlyCollection<Incident> incidents)
    {
        if (incidents.Count == 0)
        {
            return new MetricsResult(0, 0, 0, new Dictionary<Severity, int>());
        }

        var mitigationTimes = incidents
            .Select(incident => incident.GetTimeToMitigate())
            .OfType<TimeSpan>()
            .ToList();

        var bySeverity = incidents
            .GroupBy(incident => incident.Severity)
            .ToDictionary(group => group.Key, group => group.Count());

        return new MetricsResult(
            MttrHours: 0, // Requires a resolution timestamp
            MttmMinutes: mitigationTimes.Count > 0
                ? Math.Round(mitigationTimes.Average(time => time.TotalMinutes), 1)
                : 0,
            Count: incidents.Count,
            BySeverity: bySeverity);
    }
}

from collections import Counter
from collections.abc import Collection
from dataclasses import dataclass
from statistics import mean

@dataclass(frozen=True, slots=True)
class MetricsResult:
    """Aggregate incident metrics for a reporting period."""

    mttr_hours: float
    mttm_minutes: float
    count: int
    by_severity: dict[str, int]

class IncidentMetrics:
    """Computes aggregate incident metrics."""

    def calculate(self, incidents: Collection[Incident]) -> MetricsResult:
        """Compute metrics for a set of resolved incidents."""
        if not incidents:
            return MetricsResult(mttr_hours=0, mttm_minutes=0, count=0, by_severity={})

        mitigation_seconds = [
            ttm.total_seconds()
            for incident in incidents
            if (ttm := incident.time_to_mitigate()) is not None
        ]

        by_severity = Counter(incident.severity.name for incident in incidents)

        return MetricsResult(
            mttr_hours=0,  # Requires a resolution timestamp
            mttm_minutes=round(mean(mitigation_seconds) / 60, 1) if mitigation_seconds else 0.0,
            count=len(incidents),
            by_severity=dict(by_severity),
        )