Files
Febe/src/Febe.Core/Simulation/SimulationReport.cs
T
Alby96andClaude Opus 5.5 63acae4e73
verifica / controlli (push) Successful in 22s
verifica / prove (push) Successful in 21m4s
verifica / installatore (push) Successful in 5m21s
verifica / immagine (push) Successful in 19m0s
Ricette fatte di richieste, un permesso per richiesta (#36, S3)
Otto ricette (controllo del profilo, storico, taggati, reel, storie di un
account, raccolta in evidenza, post singolo, elenco dei seguiti) hanno una
strada per richieste dirette accanto a quella con il browser. Ci vanno solo
se ogni ruolo che servono è un'operazione configurata di richieste.<sito>.json:
con Instagram nessuna lo è e Febe non costruisce il client del sito, quindi il
comportamento con Instagram non cambia fino a S4.

Ogni richiesta prende il suo permesso dal Governatore nella categoria di ciò
che chiede (la prima pagina dei post conta come profilo); i segnali delle
risposte vanno all'interruttore e fermano la ricetta prima di ogni altra
richiesta. Se manca un valore o la pagina successiva, la ricetta torna alle
pagine per quella volta e il motore controlla tutti e due i tetti. I tetti non
cambiano: il dimezzamento delle storie viste è tolto perché toccava anche il
browser e i «Su misura» salvati, e resta una domanda per Alberto prima di S4.

Il simulatore ha --raccolta pagine|richieste con il costo delle operazioni
separate di Instagram: sei simulazioni di 30 giorni senza superamenti.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 12:10:54 +01:00

493 lines
23 KiB
C#

using System.Globalization;
using System.Text;
using Febe.Core.Abstractions;
using Febe.Core.Domain;
using Febe.Core.Engine;
using Febe.Core.Storage;
namespace Febe.Core.Simulation;
/// <summary>Numbers of one simulated day.</summary>
public sealed record SimulatedDay(
DateOnly Day,
int Sessions,
double ActiveMinutes,
IReadOnlyDictionary<ActionKind, long> Actions,
IReadOnlyDictionary<ActionKind, long> WorstHour,
int Throttles,
int Overruns);
/// <summary>Numbers of one budget category over the whole simulation.</summary>
public sealed record SimulatedCategory(ActionKind Kind, double MeanPerDay, long MaxPerDay, long WorstHour, long? HourlyLimit, long DailyLimit);
/// <summary>Mean and maximum of a delay, with how many cases.</summary>
public sealed record DelayStats(int Count, TimeSpan Mean, TimeSpan Max)
{
public static DelayStats From(IEnumerable<TimeSpan> delays)
{
var list = delays.ToList();
return list.Count == 0
? new DelayStats(0, TimeSpan.Zero, TimeSpan.Zero)
: new DelayStats(list.Count, TimeSpan.FromTicks((long)list.Average(d => d.Ticks)), list.Max());
}
}
/// <summary>
/// The report of the simulation (spec §14.3): sessions per day; actions per category per day and in the worst hour;
/// mean and maximum time between publication and discovery; days for the 2,000-post backfill; budget overruns (must be
/// zero). Overruns, actions outside the window and pause-floor violations are recomputed here from the database,
/// independently of the Governor.
/// </summary>
public sealed class SimulationReport
{
private static readonly ActionKind[] Categories = Enum.GetValues<ActionKind>();
private static readonly TimeSpan Hour = TimeSpan.FromMinutes(60);
public required CautionProfileKind Profile { get; init; }
/// <summary>Whether the simulated recipes went by the pages or by requests.</summary>
public SimulatedCollection Collection { get; init; }
public required int Seed { get; init; }
public required DateTimeOffset Start { get; init; }
public required DateTimeOffset End { get; init; }
public required TimeZoneInfo Zone { get; init; }
public required int Accounts { get; init; }
public required int FollowedAccounts { get; init; }
public required IReadOnlyList<SimulatedDay> Days { get; init; }
public required IReadOnlyList<SimulatedCategory> CategoryTotals { get; init; }
public required int SessionCount { get; init; }
public required double SessionsPerDayMean { get; init; }
public required int SessionsPerDayMin { get; init; }
public required int SessionsPerDayMax { get; init; }
public required TimeSpan MeanSessionLength { get; init; }
/// <summary>Coefficient of variation of the intervals between session starts (whole run).</summary>
public required double SessionStartCv { get; init; }
/// <summary>Same, only for intervals inside one day (nights excluded).</summary>
public required double SessionStartCvWithinDay { get; init; }
public required TimeSpan ShortestPause { get; init; }
public required int PauseFloorViolations { get; init; }
public required int ActionsOutsideWindow { get; init; }
public required DelayStats FollowedPosts { get; init; }
public required DelayStats NotFollowedPosts { get; init; }
public required DelayStats Stories { get; init; }
public required int PublishedPosts { get; init; }
public required int UndiscoveredPosts { get; init; }
public required int PublishedStories { get; init; }
public required int MissedStories { get; init; }
public required int BackfillPosts { get; init; }
public required int BackfillStored { get; init; }
public DateTimeOffset? BackfillFinishedAt { get; init; }
public required IReadOnlyList<Incident> Throttles { get; init; }
/// <summary>Times Febe proposed a more prudent profile (three throttles in seven days).</summary>
public required int ProposalsOfMorePrudence { get; init; }
/// <summary>Overruns of the budgets in force (gradual start and halving applied): must be zero.</summary>
public required int Overruns { get; init; }
/// <summary>Overruns of the profile's full budgets: must be zero too.</summary>
public required int OverrunsOfFullBudgets { get; init; }
public required IReadOnlyList<string> OverrunDetails { get; init; }
public required long VirtualEvents { get; init; }
/// <summary>What the fake world saw (for tests and closer looks).</summary>
public required WorldStats World { get; init; }
/// <summary>The accounts of the fake world.</summary>
public required IReadOnlyList<SimAccount> WorldAccounts { get; init; }
public required TimeSpan RealDuration { get; init; }
public double? BackfillDays => BackfillFinishedAt is { } done ? (done - Start).TotalDays : null;
internal static async Task<SimulationReport> BuildAsync(
IFebeStorage storage,
SimulatedWorld world,
EngineServices services,
SimulationOptions options,
DateTimeOffset start,
DateTimeOffset end,
long virtualEvents,
TimeSpan realDuration,
CancellationToken ct)
{
var zone = services.Clock.LocalZone;
var profile = services.Runtime.Profile;
var sessions = (await storage.Sessions.ListAsync(start, end + TimeSpan.FromDays(1), ct).ConfigureAwait(false))
.Where(s => s.StartedAt < end)
.ToList();
var actions = await storage.ActionLog.ListAsync(start, end + TimeSpan.FromDays(1), ct).ConfigureAwait(false);
var incidents = await storage.Incidents.ListAsync(start, end + TimeSpan.FromDays(1), ct).ConfigureAwait(false);
var throttles = incidents.Where(i => i.Level == SignalLevel.Throttle).ToList();
var seedText = await storage.Settings.GetAsync(EngineSettingKeys.WindowSeed, ct).ConfigureAwait(false);
var seed = ulong.TryParse(seedText, NumberStyles.Integer, CultureInfo.InvariantCulture, out var s) ? s : 0;
var rampStart = services.Runtime.RampStart;
// Halving applies after the throttle: the action that met the signal was granted before it.
DateTimeOffset? HalvedUntil(DateTimeOffset t) => throttles
.Where(i => i.At < t && i.StoppedUntil is not null)
.Select(i => (DateTimeOffset?)(i.StoppedUntil!.Value + CircuitBreaker.HalvedPeriod))
.Where(u => u > t)
.DefaultIfEmpty(null)
.Max();
// Overruns, recomputed from action_log: at every action the rolling hour and the local day so far.
var overruns = 0;
var overrunsFull = 0;
var details = new List<string>();
var overrunsByDay = new Dictionary<DateOnly, int>();
var worstHourByDay = new Dictionary<(DateOnly, ActionKind), long>();
var worstHour = new Dictionary<ActionKind, long>();
foreach (var kind in Categories)
{
var list = actions.Where(a => a.Category == kind).OrderBy(a => a.At).ThenBy(a => a.Id).ToList();
var windowStart = 0;
long windowSum = 0;
long daySum = 0;
DateOnly? currentDay = null;
for (var i = 0; i < list.Count; i++)
{
var action = list[i];
windowSum += action.Amount;
while (list[windowStart].At <= action.At - Hour)
{
windowSum -= list[windowStart].Amount;
windowStart++;
}
var day = LocalCalendar.Today(action.At, zone);
if (day != currentDay)
{
currentDay = day;
daySum = 0;
}
daySum += action.Amount;
worstHour[kind] = Math.Max(worstHour.GetValueOrDefault(kind), windowSum);
worstHourByDay[(day, kind)] = Math.Max(worstHourByDay.GetValueOrDefault((day, kind)), windowSum);
var limits = BudgetLimits.Compute(profile, rampStart, HalvedUntil(action.At), action.At);
var over = kind == ActionKind.DataDownload
? daySum > limits.DataPerDayBytes
: windowSum > limits.Budgets[kind].PerHour || daySum > limits.Budgets[kind].PerDay;
var overFull = kind == ActionKind.DataDownload
? daySum > profile.DataPerDayBytes
: windowSum > profile.Budgets[kind].PerHour || daySum > profile.Budgets[kind].PerDay;
if (over)
{
overruns++;
overrunsByDay[day] = overrunsByDay.GetValueOrDefault(day) + 1;
if (details.Count < 20)
{
details.Add(string.Create(
CultureInfo.InvariantCulture,
$"{ItalianText.Category(kind)} {LocalCalendar.ToLocal(action.At, zone):yyyy-MM-dd HH:mm:ss}: ora {windowSum}, giorno {daySum}"));
}
}
if (overFull)
{
overrunsFull++;
}
}
}
// Actions outside the active window (recomputed with the persisted seed of the daily shifts).
var outside = 0;
var windows = new Dictionary<DateOnly, ActiveWindow?>();
ActiveWindow? WindowOf(DateOnly day)
{
if (!windows.TryGetValue(day, out var w))
{
w = profile.ActiveDays.Contains(day.DayOfWeek) ? DayPlanner.Compute(day, profile, seed, zone) : null;
windows[day] = w;
}
return w;
}
foreach (var action in actions.Where(a => a.Category != ActionKind.DataDownload))
{
var today = LocalCalendar.Today(action.At, zone);
var inside = (WindowOf(today)?.Contains(action.At) ?? false) || (WindowOf(today.AddDays(-1))?.Contains(action.At) ?? false);
if (!inside)
{
outside++;
}
}
// Pauses and irregularity of the session starts.
var ordered = sessions.OrderBy(x => x.StartedAt).ToList();
var shortest = TimeSpan.MaxValue;
var floorViolations = 0;
for (var i = 1; i < ordered.Count; i++)
{
if (ordered[i - 1].EndedAt is { } previousEnd)
{
var pause = ordered[i].StartedAt - previousEnd;
shortest = pause < shortest ? pause : shortest;
if (pause < profile.PauseMin)
{
floorViolations++;
}
}
}
var intervals = new List<double>();
var withinDay = new List<double>();
for (var i = 1; i < ordered.Count; i++)
{
var gap = (ordered[i].StartedAt - ordered[i - 1].StartedAt).TotalMinutes;
intervals.Add(gap);
if (LocalCalendar.Today(ordered[i].StartedAt, zone) == LocalCalendar.Today(ordered[i - 1].StartedAt, zone) && gap < 6 * 60)
{
withinDay.Add(gap);
}
}
// Days.
var firstDay = LocalCalendar.Today(start, zone);
var lastDay = LocalCalendar.Today(end - TimeSpan.FromTicks(1), zone);
var days = new List<SimulatedDay>();
for (var day = firstDay; day <= lastDay; day = day.AddDays(1))
{
var (dayStart, dayEnd) = LocalCalendar.DayBounds(day, zone);
var daySessions = ordered.Where(x => x.StartedAt >= dayStart && x.StartedAt < dayEnd).ToList();
var active = daySessions.Sum(x => ((x.EndedAt ?? x.StartedAt) - x.StartedAt).TotalMinutes);
var counts = Categories.ToDictionary(k => k, k => actions.Where(a => a.Category == k && a.At >= dayStart && a.At < dayEnd).Sum(a => a.Amount));
var worst = Categories.ToDictionary(k => k, k => worstHourByDay.GetValueOrDefault((day, k)));
days.Add(new SimulatedDay(
day,
daySessions.Count,
active,
counts,
worst,
throttles.Count(t => t.At >= dayStart && t.At < dayEnd),
overrunsByDay.GetValueOrDefault(day)));
}
var categories = Categories.Select(k => new SimulatedCategory(
k,
days.Count == 0 ? 0 : days.Average(d => (double)d.Actions[k]),
days.Count == 0 ? 0 : days.Max(d => d.Actions[k]),
worstHour.GetValueOrDefault(k),
k == ActionKind.DataDownload ? null : profile.Budgets[k].PerHour,
k == ActionKind.DataDownload ? profile.DataPerDayBytes : profile.Budgets[k].PerDay)).ToList();
var stats = world.Stats;
return new SimulationReport
{
Profile = profile.Kind,
Collection = world.Collection,
Seed = options.Seed,
Start = start,
End = end,
Zone = zone,
Accounts = world.Accounts.Count,
FollowedAccounts = world.Accounts.Count(a => a.Followed),
Days = days,
CategoryTotals = categories,
SessionCount = ordered.Count,
SessionsPerDayMean = days.Count == 0 ? 0 : days.Average(d => d.Sessions),
SessionsPerDayMin = days.Count == 0 ? 0 : days.Min(d => d.Sessions),
SessionsPerDayMax = days.Count == 0 ? 0 : days.Max(d => d.Sessions),
MeanSessionLength = ordered.Count == 0 ? TimeSpan.Zero : TimeSpan.FromTicks((long)ordered.Average(x => ((x.EndedAt ?? x.StartedAt) - x.StartedAt).Ticks)),
SessionStartCv = Cv(intervals),
SessionStartCvWithinDay = Cv(withinDay),
ShortestPause = shortest == TimeSpan.MaxValue ? TimeSpan.Zero : shortest,
PauseFloorViolations = floorViolations,
ActionsOutsideWindow = outside,
FollowedPosts = DelayStats.From(stats.PostDiscoveries.Where(p => p.Followed).Select(p => p.Discovered - p.Published)),
NotFollowedPosts = DelayStats.From(stats.PostDiscoveries.Where(p => !p.Followed).Select(p => p.Discovered - p.Published)),
Stories = DelayStats.From(stats.StoryViews.Select(v => v.Seen - v.Published)),
PublishedPosts = world.PublishedPosts(start, end),
UndiscoveredPosts = world.UndiscoveredPosts(start, end),
PublishedStories = world.PublishedStories(start, end),
MissedStories = world.MissedStories(start, end),
BackfillPosts = (options.World ?? new SimulatedWorldOptions()).HistoricalPosts,
BackfillStored = stats.BackfillPostsStored,
BackfillFinishedAt = stats.BackfillFinishedAt,
Throttles = throttles,
ProposalsOfMorePrudence = throttles.Count(t => throttles.Count(o => o.At <= t.At && o.At > t.At - CircuitBreaker.ProposalWindow) >= CircuitBreaker.ProposalThreshold),
Overruns = overruns,
OverrunsOfFullBudgets = overrunsFull,
OverrunDetails = details,
VirtualEvents = virtualEvents,
World = stats,
WorldAccounts = world.Accounts,
RealDuration = realDuration,
};
}
/// <summary>Italian text report.</summary>
public string ToText()
{
var b = new StringBuilder();
var firstDay = LocalCalendar.Today(Start, Zone);
var lastDay = LocalCalendar.Today(End - TimeSpan.FromTicks(1), Zone);
b.AppendLine($"Simulazione del motore: {ItalianText.Count(Days.Count, "giorno", "giorni")} con il profilo «{ItalianText.Profile(Profile)}» (seme {Seed.ToString(CultureInfo.InvariantCulture)})");
b.AppendLine(Collection == SimulatedCollection.Requests ? "Raccolta: per richieste" : "Raccolta: per pagine");
b.AppendLine($"Periodo: dal {ItalianText.Day(firstDay)} alle {ItalianText.Clock(Start, Zone)} al {ItalianText.Day(lastDay)}, fuso {Zone.Id}");
b.AppendLine($"Mondo finto: {ItalianText.Number(Accounts)} account ({ItalianText.Number(FollowedAccounts)} seguiti, {ItalianText.Number(Accounts - FollowedAccounts)} no), {ItalianText.Number(PublishedPosts)} post e {ItalianText.Number(PublishedStories)} storie pubblicati nel periodo, uno storico di {ItalianText.Number(BackfillPosts)} post");
b.AppendLine("I tetti del profilo sono stime prudenti, non limiti ufficiali di Instagram.");
b.AppendLine();
b.AppendLine("Sessioni");
b.AppendLine($" al giorno: media {ItalianText.Decimal(SessionsPerDayMean, 1)}, minimo {ItalianText.Number(SessionsPerDayMin)}, massimo {ItalianText.Number(SessionsPerDayMax)} (in tutto {ItalianText.Number(SessionCount)})");
b.AppendLine($" durata media: {ItalianText.Duration(MeanSessionLength)}; pausa più breve: {ItalianText.Duration(ShortestPause)}");
b.AppendLine($" irregolarità degli inizi (coefficiente di variazione): {ItalianText.Decimal(SessionStartCv, 2)} in tutto, {ItalianText.Decimal(SessionStartCvWithinDay, 2)} dentro la giornata");
b.AppendLine();
b.AppendLine("Azioni per categoria: media al giorno, giorno peggiore, ora peggiore (tetto all'ora / al giorno)");
foreach (var c in CategoryTotals)
{
if (c.Kind == ActionKind.DataDownload)
{
b.AppendLine($" {ItalianText.CategoryLabel(c.Kind)}: {ItalianText.Bytes((long)c.MeanPerDay)} al giorno, giorno peggiore {ItalianText.Bytes(c.MaxPerDay)} (tetto {ItalianText.Bytes(c.DailyLimit)} al giorno)");
}
else
{
b.AppendLine($" {ItalianText.CategoryLabel(c.Kind)}: {ItalianText.Decimal(c.MeanPerDay, 1)} al giorno, giorno peggiore {ItalianText.Number(c.MaxPerDay)}, ora peggiore {ItalianText.Number(c.WorstHour)} (tetto {ItalianText.Number(c.HourlyLimit ?? 0)} / {ItalianText.Number(c.DailyLimit)})");
}
}
b.AppendLine();
b.AppendLine("Dalla pubblicazione alla scoperta");
b.AppendLine($" post degli account seguiti: {Delay(FollowedPosts)}");
b.AppendLine($" post degli account non seguiti: {Delay(NotFollowedPosts)}");
b.AppendLine($" storie: {Delay(Stories)}");
b.AppendLine($" post non ancora scoperti alla fine: {ItalianText.Number(UndiscoveredPosts)} di {ItalianText.Number(PublishedPosts)}; storie scadute senza essere viste: {ItalianText.Number(MissedStories)} di {ItalianText.Number(PublishedStories)}");
b.AppendLine();
b.AppendLine($"Storico di {ItalianText.Number(BackfillPosts)} post");
b.AppendLine(BackfillFinishedAt is { } done
? $" completato in {ItalianText.Decimal(BackfillDays ?? 0, 1)} giorni ({ItalianText.DayWithWeekday(LocalCalendar.Today(done, Zone))} {ItalianText.At(done, Zone)})"
: $" non completato: {ItalianText.Number(BackfillStored)} post scaricati in {ItalianText.Count(Days.Count, "giorno", "giorni")}");
b.AppendLine();
b.AppendLine("Rallentamenti simulati");
if (Throttles.Count == 0)
{
b.AppendLine(" nessuno");
}
foreach (var t in Throttles)
{
var stop = t.StoppedUntil is { } until ? ItalianText.Duration(until - t.At) : "?";
b.AppendLine($" {ItalianText.DayWithWeekday(LocalCalendar.Today(t.At, Zone))} {ItalianText.At(t.At, Zone)}: fermo di {stop}");
}
if (ProposalsOfMorePrudence > 0)
{
b.AppendLine($" proposte di passare a un profilo più prudente (tre rallentamenti in sette giorni): {ItalianText.Number(ProposalsOfMorePrudence)}");
}
b.AppendLine();
b.AppendLine("Controlli");
b.AppendLine($" superamenti dei tetti: {ItalianText.Number(Overruns)} (dei tetti pieni del profilo: {ItalianText.Number(OverrunsOfFullBudgets)})");
foreach (var detail in OverrunDetails)
{
b.AppendLine(" " + detail);
}
b.AppendLine($" azioni fuori dalla fascia oraria: {ItalianText.Number(ActionsOutsideWindow)}");
b.AppendLine($" pause più brevi della pausa minima: {ItalianText.Number(PauseFloorViolations)}");
b.AppendLine();
b.AppendLine($"Simulati {ItalianText.Number(VirtualEvents)} eventi in {ItalianText.Decimal(RealDuration.TotalSeconds, 1)} secondi.");
return b.ToString();
}
/// <summary>One row per day, ';' separated, for Excel in Italian (write it as UTF-8 with BOM).</summary>
public string ToCsv()
{
var b = new StringBuilder();
var headers = new List<string> { "giorno", "sessioni", "minuti di attività" };
headers.AddRange(Categories.Where(k => k != ActionKind.DataDownload).Select(k => ItalianText.Category(k)));
headers.Add("dati scaricati (MB)");
headers.AddRange(Categories.Where(k => k != ActionKind.DataDownload).Select(k => "ora peggiore, " + ItalianText.Category(k)));
headers.Add("rallentamenti");
headers.Add("superamenti");
b.AppendLine(string.Join(';', headers.Select(Quote)));
foreach (var day in Days)
{
var cells = new List<string>
{
day.Day.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture),
day.Sessions.ToString(CultureInfo.InvariantCulture),
ItalianText.Decimal(day.ActiveMinutes, 1, keepZeros: true).Replace(".", string.Empty, StringComparison.Ordinal),
};
cells.AddRange(Categories.Where(k => k != ActionKind.DataDownload).Select(k => day.Actions[k].ToString(CultureInfo.InvariantCulture)));
cells.Add(ItalianText.Decimal(day.Actions[ActionKind.DataDownload] / (1024.0 * 1024.0), 1, keepZeros: true).Replace(".", string.Empty, StringComparison.Ordinal));
cells.AddRange(Categories.Where(k => k != ActionKind.DataDownload).Select(k => day.WorstHour[k].ToString(CultureInfo.InvariantCulture)));
cells.Add(day.Throttles.ToString(CultureInfo.InvariantCulture));
cells.Add(day.Overruns.ToString(CultureInfo.InvariantCulture));
b.AppendLine(string.Join(';', cells));
}
return b.ToString();
}
/// <summary>Writes <see cref="ToCsv"/> as UTF-8 with BOM.</summary>
public async Task WriteCsvAsync(string path, CancellationToken ct = default)
{
ArgumentException.ThrowIfNullOrWhiteSpace(path);
await File.WriteAllTextAsync(path, ToCsv(), new UTF8Encoding(encoderShouldEmitUTF8Identifier: true), ct).ConfigureAwait(false);
}
private static string Delay(DelayStats stats) => stats.Count == 0
? "nessun caso"
: $"media {ItalianText.Duration(stats.Mean)}, massimo {ItalianText.Duration(stats.Max)} ({ItalianText.Count(stats.Count, "caso", "casi")})";
private static string Quote(string text) => text.Contains(';', StringComparison.Ordinal) || text.Contains('"', StringComparison.Ordinal)
? "\"" + text.Replace("\"", "\"\"", StringComparison.Ordinal) + "\""
: text;
private static double Cv(IReadOnlyList<double> values)
{
if (values.Count < 2)
{
return 0;
}
var mean = values.Average();
if (mean <= 0)
{
return 0;
}
var variance = values.Sum(v => (v - mean) * (v - mean)) / (values.Count - 1);
return Math.Sqrt(variance) / mean;
}
}