Обзор SRE

<?php

declare(strict_types=1);

final readonly class SliCalculator
{
    /**
     * Calculate availability SLI over a time window.
     *
     * @param int $totalRequests Total number of requests in the window
     * @param int $failedRequests Number of failed requests (5xx)
     * @return float Availability as a percentage (0-100)
     */
    public function calculateAvailability(int $totalRequests, int $failedRequests): float
    {
        if ($totalRequests === 0) {
            return 100.0;
        }

        $successfulRequests = $totalRequests - $failedRequests;

        return round(($successfulRequests / $totalRequests) * 100, 4);
    }

    /**
     * Calculate latency SLI (percentage of requests within threshold).
     *
     * @param array<float> $latencies Array of request latencies in ms
     * @param float $thresholdMs Latency threshold in milliseconds
     * @return float Percentage of requests within threshold
     */
    public function calculateLatencySli(array $latencies, float $thresholdMs): float
    {
        if (empty($latencies)) {
            return 100.0;
        }

        $withinThreshold = count(array_filter(
            $latencies,
            static fn(float $latency): bool => $latency <= $thresholdMs
        ));

        return round(($withinThreshold / count($latencies)) * 100, 4);
    }

    /**
     * Check if current SLI meets the SLO target.
     */
    public function meetsSlo(float $currentSli, float $sloTarget): bool
    {
        return $currentSli >= $sloTarget;
    }
}

// Usage
$calculator = new SliCalculator();
$availability = $calculator->calculateAvailability(
    totalRequests: 1_000_000,
    failedRequests: 500,
);
// Result: 99.95%

$meetsSlo = $calculator->meetsSlo($availability, sloTarget: 99.9);
// Result: true — we are within our error budget

package sre

import "math"

// SLICalculator computes Service Level Indicators.
type SLICalculator struct{}

// CalculateAvailability returns availability as a percentage (0-100).
func (c *SLICalculator) CalculateAvailability(totalRequests, failedRequests int) float64 {
	if totalRequests == 0 {
		return 100.0
	}
	successful := float64(totalRequests - failedRequests)
	return math.Round(successful/float64(totalRequests)*100*10000) / 10000
}

// CalculateLatencySLI returns the percentage of requests within threshold.
func (c *SLICalculator) CalculateLatencySLI(latencies []float64, thresholdMs float64) float64 {
	if len(latencies) == 0 {
		return 100.0
	}
	within := 0
	for _, l := range latencies {
		if l <= thresholdMs {
			within++
		}
	}
	return math.Round(float64(within)/float64(len(latencies))*100*10000) / 10000
}

// MeetsSLO checks if current SLI meets the SLO target.
func (c *SLICalculator) MeetsSLO(currentSLI, sloTarget float64) bool {
	return currentSLI >= sloTarget
}

// Usage:
// calc := &SLICalculator{}
// availability := calc.CalculateAvailability(1_000_000, 500) // 99.95
// meetsSLO := calc.MeetsSLO(availability, 99.9)              // true

namespace Sre;

// SliCalculator computes Service Level Indicators.
public sealed class SliCalculator
{
    // Calculate availability SLI over a time window, as a percentage (0-100).
    public double CalculateAvailability(int totalRequests, int failedRequests)
    {
        if (totalRequests == 0)
        {
            return 100.0;
        }

        var successful = totalRequests - failedRequests;

        return Math.Round((double)successful / totalRequests * 100, 4);
    }

    // Calculate latency SLI: percentage of requests within threshold.
    public double CalculateLatencySli(IReadOnlyCollection<double> latencies, double thresholdMs)
    {
        if (latencies.Count == 0)
        {
            return 100.0;
        }

        var withinThreshold = latencies.Count(latency => latency <= thresholdMs);

        return Math.Round((double)withinThreshold / latencies.Count * 100, 4);
    }

    // Check if the current SLI meets the SLO target.
    public bool MeetsSlo(double currentSli, double sloTarget) => currentSli >= sloTarget;
}

// Usage:
// var calculator = new SliCalculator();
// var availability = calculator.CalculateAvailability(totalRequests: 1_000_000, failedRequests: 500);
// // Result: 99.95
// var meetsSlo = calculator.MeetsSlo(availability, sloTarget: 99.9);
// // Result: true — we are within our error budget

from collections.abc import Sequence

class SliCalculator:
    """Computes Service Level Indicators."""

    def calculate_availability(self, total_requests: int, failed_requests: int) -> float:
        """Calculate availability SLI over a time window, as a percentage (0-100)."""
        if total_requests == 0:
            return 100.0

        successful = total_requests - failed_requests

        return round(successful / total_requests * 100, 4)

    def calculate_latency_sli(self, latencies: Sequence[float], threshold_ms: float) -> float:
        """Calculate the percentage of requests served within the threshold."""
        if not latencies:
            return 100.0

        within_threshold = sum(1 for latency in latencies if latency <= threshold_ms)

        return round(within_threshold / len(latencies) * 100, 4)

    def meets_slo(self, current_sli: float, slo_target: float) -> bool:
        """Check if the current SLI meets the SLO target."""
        return current_sli >= slo_target

# Usage
calculator = SliCalculator()
availability = calculator.calculate_availability(total_requests=1_000_000, failed_requests=500)
# Result: 99.95

meets_slo = calculator.meets_slo(availability, slo_target=99.9)
# Result: True — we are within our error budget

<?php

declare(strict_types=1);

final readonly class ErrorBudget
{
    public function __construct(
        private float $sloTarget,
        private int $windowDays = 28,
    ) {}

    /**
     * Calculate total error budget in minutes.
     */
    public function totalBudgetMinutes(): float
    {
        $totalMinutes = $this->windowDays * 24 * 60;
        $budgetFraction = 1 - ($this->sloTarget / 100);

        return $totalMinutes * $budgetFraction;
    }

    /**
     * Calculate remaining error budget.
     *
     * @param float $downtimeMinutes Downtime consumed so far
     * @return array{remaining_minutes: float, remaining_percent: float, status: string}
     */
    public function remaining(float $downtimeMinutes): array
    {
        $total = $this->totalBudgetMinutes();
        $remaining = $total - $downtimeMinutes;
        $remainingPercent = ($remaining / $total) * 100;

        $status = match (true) {
            $remainingPercent > 50 => 'healthy',
            $remainingPercent > 25 => 'caution',
            $remainingPercent > 0  => 'critical',
            default                => 'exhausted',
        };

        return [
            'remaining_minutes' => round($remaining, 2),
            'remaining_percent' => round($remainingPercent, 2),
            'status' => $status,
        ];
    }
}

$budget = new ErrorBudget(sloTarget: 99.9, windowDays: 28);
// Total budget: ~40.32 minutes

$status = $budget->remaining(downtimeMinutes: 15.0);
// remaining_percent: ~62.8%, status: "healthy"

package sre

import "math"

// ErrorBudget tracks the remaining error budget based on an SLO target.
type ErrorBudget struct {
	SLOTarget  float64 // e.g., 99.9
	WindowDays int     // e.g., 28
}

// BudgetStatus holds the remaining error budget information.
type BudgetStatus struct {
	RemainingMinutes float64 `json:"remaining_minutes"`
	RemainingPercent float64 `json:"remaining_percent"`
	Status           string  `json:"status"`
}

// TotalBudgetMinutes returns the total error budget in minutes.
func (eb *ErrorBudget) TotalBudgetMinutes() float64 {
	totalMinutes := float64(eb.WindowDays) * 24 * 60
	budgetFraction := 1 - (eb.SLOTarget / 100)
	return totalMinutes * budgetFraction
}

// Remaining calculates how much error budget is left.
func (eb *ErrorBudget) Remaining(downtimeMinutes float64) BudgetStatus {
	total := eb.TotalBudgetMinutes()
	remaining := total - downtimeMinutes
	remainingPct := (remaining / total) * 100

	var status string
	switch {
	case remainingPct > 50:
		status = "healthy"
	case remainingPct > 25:
		status = "caution"
	case remainingPct > 0:
		status = "critical"
	default:
		status = "exhausted"
	}

	return BudgetStatus{
		RemainingMinutes: math.Round(remaining*100) / 100,
		RemainingPercent: math.Round(remainingPct*100) / 100,
		Status:           status,
	}
}

// Usage:
// budget := &ErrorBudget{SLOTarget: 99.9, WindowDays: 28}
// // Total budget: ~40.32 minutes
// status := budget.Remaining(15.0)
// // RemainingPercent: ~62.8%, Status: "healthy"

namespace Sre;

// BudgetStatus holds the remaining error budget information.
public readonly record struct BudgetStatus(
    double RemainingMinutes,
    double RemainingPercent,
    string Status);

// ErrorBudget tracks the remaining error budget based on an SLO target.
public sealed class ErrorBudget(double sloTarget, int windowDays = 28)
{
    // Total error budget in minutes for the window.
    public double TotalBudgetMinutes()
    {
        var totalMinutes = windowDays * 24 * 60;
        var budgetFraction = 1 - (sloTarget / 100);

        return totalMinutes * budgetFraction;
    }

    // Calculate how much error budget is left after the consumed downtime.
    public BudgetStatus Remaining(double downtimeMinutes)
    {
        var total = TotalBudgetMinutes();
        var remaining = total - downtimeMinutes;
        var remainingPercent = remaining / total * 100;

        var status = remainingPercent switch
        {
            > 50 => "healthy",
            > 25 => "caution",
            > 0 => "critical",
            _ => "exhausted",
        };

        return new BudgetStatus(
            Math.Round(remaining, 2),
            Math.Round(remainingPercent, 2),
            status);
    }
}

// Usage:
// var budget = new ErrorBudget(sloTarget: 99.9, windowDays: 28);
// // Total budget: ~40.32 minutes
// var status = budget.Remaining(15.0);
// // RemainingPercent: ~62.8, Status: "healthy"

from dataclasses import dataclass
from typing import Literal

BudgetState = Literal["healthy", "caution", "critical", "exhausted"]

@dataclass(frozen=True, slots=True)
class BudgetStatus:
    """Remaining error budget information."""

    remaining_minutes: float
    remaining_percent: float
    status: BudgetState

@dataclass(frozen=True, slots=True)
class ErrorBudget:
    """Tracks the remaining error budget based on an SLO target."""

    slo_target: float  # e.g. 99.9
    window_days: int = 28

    def total_budget_minutes(self) -> float:
        """Total error budget in minutes for the window."""
        total_minutes = self.window_days * 24 * 60
        budget_fraction = 1 - (self.slo_target / 100)

        return total_minutes * budget_fraction

    def remaining(self, downtime_minutes: float) -> BudgetStatus:
        """Calculate how much error budget is left."""
        total = self.total_budget_minutes()
        remaining = total - downtime_minutes
        remaining_percent = remaining / total * 100

        status: BudgetState
        if remaining_percent > 50:
            status = "healthy"
        elif remaining_percent > 25:
            status = "caution"
        elif remaining_percent > 0:
            status = "critical"
        else:
            status = "exhausted"

        return BudgetStatus(
            remaining_minutes=round(remaining, 2),
            remaining_percent=round(remaining_percent, 2),
            status=status,
        )

budget = ErrorBudget(slo_target=99.9, window_days=28)
# Total budget: ~40.32 minutes

status = budget.remaining(downtime_minutes=15.0)
# remaining_percent: ~62.8, status: "healthy"