Large Scale System Architecture and Evolution Questions

import pandas as pd
import numpy as np
from datetime import timedelta

SLO = 0.999  # example SLO (99.9%)
ROLL_MINUTES = 28 * 24 * 60
BURN_WINDOW_DAYS = 7  # window to compute current burn rate

def load_and_prepare(path):
    df = pd.read_csv(path, parse_dates=['timestamp'])
    df = df.set_index('timestamp').sort_index()
    # ensure minute-level index; fill missing minutes with zeros (assumption: no traffic)
    idx = pd.date_range(df.index.min(), df.index.max(), freq='T')
    df = df.reindex(idx, fill_value=0)
    df['requests'] = df['requests'].astype(float)
    df['errors'] = df['errors'].astype(float)
    return df

def compute_rolling_sli(df):
    # rolling sums over ROLL_MINUTES
    req_sum = df['requests'].rolling(window=ROLL_MINUTES, min_periods=1).sum()
    err_sum = df['errors'].rolling(window=ROLL_MINUTES, min_periods=1).sum()
    # avoid divide by zero: if req_sum==0, set availability to 1.0 (no traffic => no error impact)
    sli = 1.0 - (err_sum / req_sum).replace([np.inf, -np.inf], 0).fillna(0)
    sli[req_sum == 0] = 1.0
    return sli

def compute_burn_rate(df, sli_series, slo=SLO, burn_window_days=BURN_WINDOW_DAYS):
    # compute error budget consumed over burn_window_days
    end = df.index.max()
    start = end - pd.Timedelta(days=burn_window_days)
    window = df.loc[start:end]
    req = window['requests'].sum()
    err = window['errors'].sum()
    if req == 0:
        return 0.0  # no traffic => no burn
    availability = 1.0 - err / req
    error_budget = 1.0 - slo
    consumed = max(0.0, slo - availability)  # fraction of SLA missed relative to 1.0
    # consumed fraction of total (over period) = (slo - availability); burned fraction of error budget:
    burned_fraction = consumed / error_budget if error_budget > 0 else float('inf')
    # normalize to per-day burn rate
    days = burn_window_days
    burn_rate_per_day = burned_fraction / days
    return burn_rate_per_day

def forecast_time_to_breach(df, slo=SLO):
    sli = compute_rolling_sli(df)
    current_sli = sli.iloc[-1]
    error_budget = 1.0 - slo
    consumed_fraction = max(0.0, slo - current_sli) / error_budget if error_budget>0 else float('inf')
    # remaining error budget fraction
    remaining = max(0.0, 1.0 - consumed_fraction)
    burn_rate_per_day = compute_burn_rate(df, sli, slo)
    if burn_rate_per_day <= 0:
        return np.inf  # not burning or improving
    days_until_breach = remaining / burn_rate_per_day
    return {
        'current_sli': current_sli,
        'burn_rate_per_day': burn_rate_per_day,
        'days_until_breach': days_until_breach
    }

# Example usage:
# df = load_and_prepare('minutes.csv')
# result = forecast_time_to_breach(df, slo=0.999)
# print(result)