Spitzennutzung von Lizenzen für die Nachberechnung
Bei der Verlängerung müssen Sie wissen, wie viele Floating-Lizenzen ein Kunde tatsächlich gleichzeitig genutzt hat — weder der heutige Stand noch die Summe aller Aktivierungen. Dieser Deep Dive leitet die exakte Zahl aus dem Lease-Ereignisprotokoll mit einer Sweep-Line ab, behandelt Leases, die über die Abrechnungsfenstergrenze reichen, und Leases, die der Reaper implizit geschlossen hat, und zeigt, warum ein zeitgewichteter p95 ehrlicher abrechnet als die rohe Spitze.
Ein Anbieter verkauft einen Floating-Pool: fünfzig gleichzeitige Lizenzen, jährlich abgerechnet, Nachberechnung bei der Verlängerung. Zwölf Monate später ist die Frage auf der Rechnung trügerisch einfach: Wie viele Lizenzen haben sie tatsächlich genutzt? Die naiven Antworten sind beide falsch. Zählen Sie die jetzt aktiven Lizenzen, und Sie erhalten, was die Uhr gerade erfasst hat, meist eine ruhige Zahl. Summieren Sie alle Aktivierungen des Jahres, und Sie berechnen tausend, weil eine Lizenz, die zwischen zweihundert Nutzern rotiert, wie zweihundert Lizenzen aussieht. Keine ist die Menge, die der Vertrag rationiert.
Kernaussage: Die Zahl, gegen die ein Floating-Vertrag geschrieben ist, ist die Spitzenkonkurrenz — die größte Menge an Leases, die zu einem Augenblick im Abrechnungsfenster gleichzeitig offen waren. Sie berechnen sie exakt, nicht durch Stichproben, mit einer Sweep-Line über das Lease-Ereignisprotokoll: Sortieren Sie die Acquire- und Release-Ereignisse nach Zeit, durchlaufen Sie sie mit einem laufenden Zähler und merken Sie sich das erreichte Maximum. Die Feinheiten liegen alle an den Rändern — Leases, die die Fenstergrenze überschreiten, und Leases, die der Reaper implizit geschlossen hat — und ein zeitgewichtetes Perzentil rechnet in der Regel ehrlicher ab als das rohe Maximum.
Die eigentliche Frage: Wie viele Leases haben sich überschnitten?
Keyright protokolliert die Aktivität von Floating-Lizenzen als Lease-Protokoll. Jeder Check-out ist ein Acquire; jeder Check-in, jeder Ablauf oder jeder Reaper-Durchlauf ist ein Release. Für die Nachberechnung ist das Rohmaterial eine Liste von Intervallen — eines pro Lease — jeweils mit einem Anfang und einem Ende:
public readonly record struct LeaseInterval(DateTimeOffset Start, DateTimeOffset End);
Die Spitzenkonkurrenz ist die maximale Anzahl dieser Intervalle, die sich an einem einzigen Zeitpunkt überschneiden. Sie könnten sie per Stichprobe beantworten — die aktiven Leases jede Minute zählen und das Maximum nehmen —, aber Stichproben verfehlen eine Spitze, die zwischen zwei Ticks lebt, und ein Kunde, der eine Nachberechnung anficht, ist genau das Publikum, das bemerken wird, dass Sie geraten haben. Die exakte Antwort ist günstig, also berechnen Sie die exakte Antwort.
Der Mechanismus: eine Sweep-Line über die Lease-Ereignisse
Der Trick besteht darin, aufzuhören, in Intervallen zu denken, und in Ereignissen zu denken. Jedes Lease trägt zwei bei: ein +1 an seinem Anfang und ein -1 an seinem Ende. Sortieren Sie jedes Ereignis nach Zeitstempel, durchlaufen Sie die Liste von links nach rechts mit einer laufenden Summe, und die Summe zu jedem Zeitpunkt ist die Anzahl der zu diesem Zeitpunkt offenen Leases. Der größte Wert, den die Summe je erreicht, ist die Spitze.
Zwei Details machen den Durchlauf korrekt. Erstens: Beschneiden Sie jedes Lease auf das Abrechnungsfenster, bevor Sie seine Ereignisse ausgeben — ein Lease, das in der Vorperiode begann, belegt am 1. Januar noch eine Lizenz, und ein zum Jahresende noch offenes Lease belegt bis zum 31. Dezember eine. Zweitens: Wenn ein Release und ein Acquire auf denselben Augenblick fallen, verarbeiten Sie zuerst das Release; andernfalls liest sich eine direkt von einem Nutzer zum nächsten weitergereichte Lizenz als zwei überlappende Leases für einen Tick.
public static int PeakConcurrency(
IEnumerable<LeaseInterval> leases,
DateTimeOffset windowStart,
DateTimeOffset windowEnd)
{
var events = new List<(DateTimeOffset At, int Delta)>();
foreach (var l in leases)
{
// Clamp to the billing window: a lease open across a boundary
// still holds a seat for the part that falls inside the period.
var start = l.Start < windowStart ? windowStart : l.Start;
var end = l.End > windowEnd ? windowEnd : l.End;
if (end <= start) continue; // no overlap with this window
events.Add((start, +1));
events.Add((end, -1));
}
// Ties: -1 (release) before +1 (acquire), so a back-to-back
// handoff of one seat never reads as two.
events.Sort((a, b) =>
a.At != b.At ? a.At.CompareTo(b.At) : a.Delta.CompareTo(b.Delta));
int current = 0, peak = 0;
foreach (var e in events)
{
current += e.Delta;
if (current > peak) peak = current;
}
return peak;
}
Das ist der gesamte Algorithmus: O(n log n) für die Sortierung, ein linearer Durchlauf, keine Stichproben, und die Antwort ist exakt. Ein Jahr eines Fünfzig-Lizenzen-Pools sind höchstens ein paar hunderttausend Ereignisse — Millisekunden.
Der Rand, der wirklich wehtut: die Leases, die der Reaper geschlossen hat
Der obige Code setzt voraus, dass jedes Lease ein sauberes End hat. In einem echten Floating-System haben viele das nicht. Ein Laptop, der in den Ruhezustand geht, ein Prozess, der beendet wird, ein Container, der verdrängt wird — keiner sendet einen Check-in. Das Lease hört einfach auf, Heartbeats zu senden, und der Reaper des Servers holt die Lizenz zurück, sobald die Lease-TTL ohne Heartbeat abläuft. (Dieser Reaping-Mechanismus ist ein eigenes Thema; siehe den Beitrag zum Heartbeat-Lease-Reaping.)
Für die Abrechnung hat ein vom Reaper eingesammeltes Lease nicht bis zu dem Moment eine Lizenz belegt, in dem der Reaper es bemerkte. Es belegte eine bis zum letzten Heartbeat, plus die Kulanz, die Sie zu gewähren bereit sind. Einem Kunden die volle TTL nach einem abgestürzten Prozess zu berechnen, würde jede Spitze aufblähen. Das effektive Ende eines Lease ist also sein explizites Release, falls es eines hat, und andernfalls sein letzter Heartbeat plus die TTL:
public static LeaseInterval ToInterval(LeaseRow row, TimeSpan leaseTtl)
{
DateTimeOffset end = row.ReleasedAt // clean check-in
?? row.LastHeartbeatAt + leaseTtl; // reaped: held until TTL lapsed
return new LeaseInterval(row.AcquiredAt, end);
}
Irren Sie in die großzügige Richtung, und jeder instabile Client polstert die Spitze; irren Sie in die knauserige Richtung, und Sie berechnen die echte Nutzung zu niedrig. Die TTL, die Sie bereits für das Reaping gewählt haben, ist die vertretbare Antwort — es ist das Fenster, in dem der Server die Lizenz wirklich als gehalten behandelt hat.
Auf den p95 abrechnen, nicht auf die rohe Spitze
Die absolute Spitze ist ehrlich, aber fragil. Ein All-Hands, bei dem sich drei Auftragnehmer fünf Minuten lang anmeldeten, kann einen Kunden mit fünfzig Lizenzen auf dreiundfünfzig treiben, und eine dauerhafte Erhöhung um drei Lizenzen auf einen Fünf-Minuten-Ausschlag zu berechnen, ist ein Verlängerungsstreit, den Sie verlieren werden. Ein zeitgewichtetes Perzentil rechnet auf die anhaltende Nachfrage statt auf den schlimmsten Augenblick ab.
Berechnen Sie es aus demselben Ereignisstrom. Durchlaufen Sie die sortierten Ereignisse und akkumulieren Sie für jede Lücke zwischen aufeinanderfolgenden Ereignissen die Dauer der Lücke in einen Bucket, der nach dem Konkurrenzniveau während dieser Lücke indiziert ist. Sie erhalten „auf jedem Niveau verbrachte Sekunden”, und der p95 ist das niedrigste Niveau, unter dem sich 95 % der Fensterzeit ansammeln:
public static int PercentileConcurrency(
IReadOnlyList<(DateTimeOffset At, int Delta)> sortedEvents,
double percentile)
{
var secondsAtLevel = new SortedDictionary<int, double>();
int current = 0;
for (int i = 0; i + 1 < sortedEvents.Count; i++)
{
current += sortedEvents[i].Delta;
double seconds = (sortedEvents[i + 1].At - sortedEvents[i].At).TotalSeconds;
if (seconds > 0)
{
secondsAtLevel.TryGetValue(current, out var acc);
secondsAtLevel[current] = acc + seconds;
}
}
double total = secondsAtLevel.Values.Sum();
double cutoff = total * percentile;
double running = 0;
foreach (var (level, seconds) in secondsAtLevel) // ascending
{
running += seconds;
if (running >= cutoff) return level;
}
return secondsAtLevel.Count == 0 ? 0 : secondsAtLevel.Keys.Max();
}
Berichten Sie beide. Der p95 verankert die Nachberechnung; die rohe Spitze ist die ehrliche Obergrenze, die Sie in der Akte behalten, falls ein Kunde fragt, wie der arbeitsreichste Augenblick aussah.
Den Bericht ziehen
Nichts davon sollte der Kunde von Hand zusammenstellen. Keyright stellt die Lease-Historie über die Admin-API bereit, und die CLI umhüllt die Sweep-Line, sodass ein Betreiber die fertigen Zahlen erhält:
keyright report seats \
--product acme-suite \
--from 2026-01-01 --to 2026-12-31 \
--metric peak,p95 --tz America/New_York
{
"product": "acme-suite",
"window": { "from": "2026-01-01", "to": "2026-12-31" },
"entitled": 50,
"peak": 53,
"p95": 47,
"peakAt": "2026-09-18T14:32:07-04:00",
"overageBasis": "p95"
}
Das Flag --tz zählt mehr, als es scheint: „die Spitzenkonkurrenz während des Abrechnungsjahres” ist durch Mitternacht bis Mitternacht in der lokalen Zeit des Kunden begrenzt, und sie in UTC zu berechnen verschmiert seinen 31. Dezember über zwei Ihrer Tage. Lösen Sie das Fenster in der Zeitzone des Kunden auf und beschneiden Sie dann.
Vorbehalte
Nur Floating. Dies misst Konkurrenz, die nur für einen Floating-Pool sinnvoll ist. Ein benannter-Nutzer-Anspruch rechnet über den Zeitraum auf verschiedene Identitäten ab — ein COUNT(DISTINCT user), kein Sweep — und eine knotengebundene Lizenz rechnet auf gebundene Maschinen ab. Führen Sie die richtige Abfrage für das Lizenzmodell aus; die Sweep-Line beantwortet speziell die Floating-Frage.
Uhrzeit-Vertrauen über Knoten hinweg. In einem Multi-Knoten-Deployment kommen die Lease-Zeitstempel von demjenigen Knoten, der den Heartbeat bedient hat. Ein paar Sekunden Versatz zwischen Knoten verschieben eine über Minuten anhaltende Spitze nicht, können aber eine Ein-Sekunden-Phantomüberlappung erzeugen oder löschen. Rechnen Sie auf den p95 ab, der gegen ein Einzel-Tick-Artefakt immun ist, und behandeln Sie die rohe Spitze als Hinweis statt als Rechnungsposten.
Die TTL des eingesammelten Lease ist eine Richtlinie, keine Tatsache. Das effektive Ende eines abgestürzten Lease ist eine Entscheidung: letzter Heartbeat plus TTL. Sie ist vertretbar, weil der Server die Lizenz genau für diese Spanne als gehalten behandelt hat, aber sie bleibt Ihre Richtlinie, also dokumentieren Sie sie im Vertrag. Ein Kunde, der „Spitze 53” sieht, sollte erfahren können, dass ein eingesammeltes Lease bis zum Ablauf seiner TTL zählt.
Der Bericht ist nur so gut wie das Protokoll. Wenn Heartbeats verloren gehen oder Lease-Ereignisse verworfen werden, berechnet die Sweep-Line die Spitze dessen, was sie hat, nicht dessen, was geschah. Dauerhafte, geordnete Lease-Ereignisse sind das Fundament; die Arithmetik darüber ist der einfache Teil.
Fazit
Die Nachberechnung von Floating-Lizenzen ist weder eine Momentaufnahme noch eine Summe — sie ist die maximale Überlappung der Lease-Intervalle über das Abrechnungsfenster, und Sie erhalten sie exakt mit einer Sweep-Line: Geben Sie pro Lease ein +1 und ein -1 aus, beschneiden Sie auf das Fenster, sortieren Sie mit den Releases vor den Acquires und verfolgen Sie das laufende Maximum. Schließen Sie vom Reaper eingesammelte Leases bei ihrem letzten Heartbeat plus TTL, damit ein abgestürzter Client die Rechnung nicht aufbläht, verankern Sie die Rechnung an einem zeitgewichteten p95 statt an einer fragilen Einzel-Augenblick-Spitze, und lösen Sie das Fenster in der eigenen Zeitzone des Kunden auf. Keyright bewahrt die Lease-Historie auf und liefert den Befehl report seats, damit die Zahl vertretbar ist, bevor sie überhaupt eine Rechnung erreicht; die Community Edition ist kostenlos und selbst gehostet, sodass Sie einen Floating-Pool modellieren und seinen Nachberechnungsbericht von Anfang bis Ende lesen können, bevor Sie sich festlegen. Die vollständige Admin-API-Oberfläche steht in der Keyright-Dokumentation.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.