Calcular el uso máximo de licencias para la regularización
En la renovación necesitas saber cuántas licencias flotantes usó realmente un cliente a la vez: ni el recuento de hoy, ni la suma de todas las activaciones. Este análisis en profundidad deriva el número exacto del registro de eventos de lease con una línea de barrido, trata los leases que cruzan la ventana de facturación y los que el reaper cerró de forma implícita, y muestra por qué un p95 ponderado por tiempo factura con más honestidad que el pico bruto.
Un proveedor vende un pool flotante: cincuenta licencias concurrentes, facturadas anualmente, con regularización en la renovación. Doce meses después, la pregunta en la factura es engañosamente simple: ¿cuántas licencias usaron realmente? Las respuestas ingenuas son ambas incorrectas. Cuenta las licencias activas ahora mismo y obtienes lo que el reloj haya capturado, normalmente un número tranquilo. Suma todas las activaciones del año y facturas mil, porque una licencia que rota entre doscientos usuarios parece doscientas. Ninguna es la cantidad que raciona el contrato.
Idea clave: El número contra el que se escribe un contrato flotante es la concurrencia máxima: el mayor conjunto de leases que estuvieron abiertos a la vez en algún instante de la ventana de facturación. Lo calculas de forma exacta, no por muestreo, con una línea de barrido sobre el registro de eventos de lease: ordena los eventos de adquisición y liberación por tiempo, recórrelos manteniendo un contador y recuerda el máximo alcanzado. Las sutilezas están todas en los bordes —leases que cruzan el límite de la ventana y leases que el reaper cerró de forma implícita— y un percentil ponderado por tiempo normalmente factura con más honestidad que el máximo bruto.
La pregunta real: ¿cuántos leases se solaparon?
Keyright registra la actividad de las licencias flotantes como un registro de leases. Cada check-out es una adquisición; cada check-in, expiración o barrido del reaper es una liberación. Para la regularización, la materia prima es una lista de intervalos —uno por lease—, cada uno con un inicio y un fin:
public readonly record struct LeaseInterval(DateTimeOffset Start, DateTimeOffset End);
La concurrencia máxima es el número máximo de estos intervalos que se solapan en un único punto en el tiempo. Podrías responderlo por muestreo —contar los leases activos cada minuto y tomar el máximo—, pero el muestreo se pierde un pico que vive entre dos marcas de tiempo, y un cliente que disputa una regularización es exactamente el público que notará que lo adivinaste. La respuesta exacta es barata, así que calcula la respuesta exacta.
El mecanismo: una línea de barrido sobre los eventos de lease
El truco está en dejar de pensar en intervalos y pensar en eventos. Cada lease aporta dos: un +1 en su inicio y un -1 en su fin. Ordena cada evento por marca de tiempo, recorre la lista de izquierda a derecha llevando una suma acumulada, y la suma en cualquier momento es el número de leases abiertos en ese momento. El mayor valor que alcanza la suma es el pico.
Dos detalles hacen correcto el recorrido. Primero, recorta cada lease a la ventana de facturación antes de emitir sus eventos: un lease que empezó en el periodo anterior sigue ocupando una licencia el 1 de enero, y un lease aún abierto a fin de año ocupa una hasta el 31 de diciembre. Segundo, cuando una liberación y una adquisición caen en el mismo instante, procesa primero la liberación; de lo contrario, una licencia pasada directamente de un usuario a otro se lee como dos leases solapados durante una marca de tiempo.
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;
}
Ese es todo el algoritmo: O(n log n) por la ordenación, una pasada lineal, sin muestreo, y la respuesta es exacta. Un año de un pool de cincuenta licencias son unos cientos de miles de eventos como mucho: milisegundos.
El borde que de verdad duele: los leases que cerró el reaper
El código anterior supone que cada lease tiene un End limpio. En un sistema flotante real, muchos no lo tienen. Un portátil que se suspende, un proceso que se mata, un contenedor que se desaloja: ninguno envía un check-in. El lease simplemente deja de emitir heartbeats, y el reaper del servidor reclama la licencia una vez que el TTL del lease transcurre sin heartbeat. (Ese mecanismo de reaping es un tema propio; véase el artículo sobre el reaping de leases por heartbeat.)
Para la facturación, un lease recuperado por el reaper no ocupó una licencia hasta que el reaper se dio cuenta. La ocupó hasta el último heartbeat, más el margen que estés dispuesto a conceder. Cobrar a un cliente el TTL completo tras un proceso que se bloqueó inflaría cada pico. Así que el fin efectivo de un lease es su liberación explícita si la tiene y, de lo contrario, su último heartbeat más el 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);
}
Equivócate en la dirección generosa y cada cliente inestable rellena el pico; equivócate en la dirección tacaña y subfacturas el uso real. El TTL que ya elegiste para el reaping es la respuesta defendible: es la ventana durante la cual el servidor trató genuinamente la licencia como tomada.
Facturar sobre el p95, no sobre el pico bruto
El pico absoluto es honesto pero frágil. Una reunión general en la que tres contratistas iniciaron sesión durante cinco minutos puede empujar a un cliente de cincuenta licencias a cincuenta y tres, y facturar un aumento permanente de tres licencias por un repunte de cinco minutos es una discusión de renovación que perderás. Un percentil ponderado por tiempo factura sobre la demanda sostenida en lugar del peor instante.
Calcúlalo a partir del mismo flujo de eventos. Recorre los eventos ordenados y, para cada hueco entre eventos consecutivos, acumula la duración del hueco en un bucket indexado por el nivel de concurrencia durante ese hueco. Acabas con “segundos pasados en cada nivel”, y el p95 es el nivel más bajo bajo el cual se acumula el 95% del tiempo de la ventana:
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();
}
Informa de ambos. El p95 ancla la regularización; el pico bruto es el techo honesto que guardas en el registro por si un cliente pregunta cómo fue el instante de mayor actividad.
Obtener el informe
Nada de esto es algo que el cliente deba ensamblar a mano. Keyright expone el historial de leases a través de la API de administración, y la CLI envuelve la línea de barrido para que un operador obtenga los números ya terminados:
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"
}
El flag --tz importa más de lo que parece: “la concurrencia máxima durante el año de facturación” está acotada por la medianoche-a-medianoche local del cliente, y calcularla en UTC embadurna su 31 de diciembre a lo largo de dos de tus días. Resuelve la ventana en la zona horaria del cliente y luego recorta.
Advertencias
Solo flotante. Esto mide concurrencia, que solo es significativa para un pool flotante. Un derecho de usuario nominal factura sobre identidades distintas a lo largo del periodo —un COUNT(DISTINCT user), no un barrido— y una licencia anclada a nodo factura sobre máquinas vinculadas. Ejecuta la consulta correcta para el modelo de licencia; la línea de barrido responde específicamente a la pregunta flotante.
Confianza en el reloj entre nodos. En un despliegue multinodo, las marcas de tiempo de los leases vienen de cualquier nodo que haya servido el heartbeat. Unos segundos de desfase entre nodos no moverán un pico sostenido durante minutos, pero pueden crear o borrar un solapamiento fantasma de un segundo. Factura sobre el p95, que es inmune a un artefacto de una sola marca, y trata el pico bruto como indicativo en vez de como línea de factura.
El TTL del lease recuperado es una política, no un hecho. El fin efectivo de un lease bloqueado es una elección: último heartbeat más TTL. Es defendible porque el servidor trató la licencia como tomada durante exactamente ese lapso, pero sigue siendo tu política, así que documéntala en el contrato. Un cliente que ve “pico 53” debería poder enterarse de que un lease recuperado cuenta hasta que su TTL transcurre.
El informe es tan bueno como el registro. Si se pierden heartbeats o se descartan eventos de lease, la línea de barrido calcula el pico de lo que tiene, no de lo que ocurrió. Eventos de lease duraderos y ordenados son el cimiento; la aritmética encima es la parte fácil.
Conclusión
La regularización de licencias flotantes no es una instantánea ni una suma: es el solapamiento máximo de los intervalos de lease a lo largo de la ventana de facturación, y lo obtienes de forma exacta con una línea de barrido: emite un +1 y un -1 por lease, recorta a la ventana, ordena con las liberaciones antes que las adquisiciones y sigue el máximo acumulado. Cierra los leases recuperados por el reaper en su último heartbeat más el TTL para que un cliente bloqueado no infle la factura, ancla la factura en un p95 ponderado por tiempo en lugar de un pico frágil de un solo instante, y resuelve la ventana en la zona horaria propia del cliente. Keyright mantiene el historial de leases y trae el comando report seats para que el número sea defendible antes de que llegue a una factura; la Community Edition es gratuita y autoalojada, así que puedes modelar un pool flotante y leer su informe de regularización de principio a fin antes de comprometerte. Toda la superficie de la API de administración está en la documentación de Keyright.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.