dsh-all-usage 1.1.3 → 1.1.5

package/lib/aggregation.js

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto'
-import { COST_SCHEMA_VERSION, addCostAccumulator, addCostAggregate, calculateCost, createCostAccumulator, decimalSubtract, isCostAccumulator, normalizeCostSnapshot, resolvePricing, serializeCostAggregate } from './pricing.js'
+import { COST_SCHEMA_VERSION, addCostAccumulator, addCostAggregate, calculateCost, createCostAccumulator, decimalSubtract, isCostAccumulator, normalizeCostSnapshot, resolvePricing, serializeCostAggregate, temporalPlanFor } from './pricing.js'
 import { extractUsageEvent, normalizeEventSeq, normalizeUsageValues as usageValues, upsertUsageSample as upsertUsageSampleState, usageStepKey, validEventTime as validUsageEventTime } from './usage-core.js'
 
 export function createAggregation(host) {
@@ -75,14 +75,23 @@ export function createAggregation(host) {
     while (state.pricingResolutionCache.size > 5000) state.pricingResolutionCache.delete(state.pricingResolutionCache.keys().next().value)
     return resolved
   }
-  function costForUsage(values, identity, previous) {
+  function costForUsage(values, identity, previous, pricingAt, pricingTimeSource) {
     const previousCost = normalizeCostSnapshot(previous && previous.cost)
-    if (previousCost !== null && previousCost.pricingMode === 'official-model' && usageBasisEqual(previous, identity, values)) return previousCost
-    return calculateCost(values, resolveCurrentPricing(identity))
+    if (previousCost !== null && previousCost.pricingMode === 'official-model' && previousCost.pricingTimeSource !== 'legacy-unknown' && usageBasisEqual(previous, identity, values) && costTemporalCompatible(previousCost, identity, pricingAt, pricingTimeSource)) return previousCost
+    return calculateCost(values, resolveCurrentPricing(identity), pricingAt, pricingTimeSource)
+  }
+  function costTemporalCompatible(previousCost, identity, pricingAt, pricingTimeSource) {
+    if (previousCost.pricingAt === null || previousCost.pricingTimeSource === null) return false
+    const resolved = resolveCurrentPricing(identity)
+    const plan = temporalPlanFor(resolved, pricingAt)
+    const normalizedAt = Number.isFinite(pricingAt) && pricingAt >= 0 ? Math.trunc(pricingAt) : null
+    const normalizedSource = pricingTimeSource === 'request-context' || pricingTimeSource === 'usage-event' ? pricingTimeSource : 'usage-event'
+    return previousCost.pricingBand === plan.band && previousCost.pricingPolicyId === plan.policyId && previousCost.pricingPolicyHash === plan.policyHash && previousCost.pricingTimezone === plan.timezone && previousCost.temporalApplicable === (plan.status === 'applied') && previousCost.temporalExemptReason === plan.exemptReason && previousCost.pricingAt === normalizedAt && previousCost.pricingTimeSource === normalizedSource
   }
   function resetAggregationState() {
     state.aggregationGeneration += 1
     state.wsMeta.clear()
+    if (state.sessionContextTimes) state.sessionContextTimes.clear()
     state.pathIndex.clear()
     state.memberOf.clear()
     state.byDay.clear()
@@ -343,10 +352,35 @@ export function createAggregation(host) {
     adjustDay(state.byDay, dates.local, wsId, values, normalized, direction, sid, cost)
     adjustDay(state.byDayUtc, dates.utc, wsId, values, normalized, direction, sid, cost)
   }
+  function removeSession(sid) {
+    if (typeof sid !== 'string' || sid === '') return 0
+    let removed = 0
+    const usageKeys = []
+    for (const [key, item] of state.usageByStep) if (item.sid === sid) usageKeys.push([key, item])
+    for (const [key, item] of usageKeys) {
+      unindexUsage(item)
+      adjustUsage(item.wsId, item.time, item.values, item.identity || item.modelId, -1, sid, { local: item.date, utc: item.dateUtc }, item.cost)
+      adjustQueryUsage(state.byDay.get(item.date), item, -1, false)
+      adjustQueryUsage(state.byDayUtc.get(item.dateUtc), item, -1, true)
+      state.usageByStep.delete(key)
+      removed += 1
+    }
+    const turnKeys = []
+    for (const [key, turn] of state.turnRecords) if (turn.sid === sid) turnKeys.push([key, turn])
+    for (const [key, turn] of turnKeys) {
+      removeTurnRecord(turn)
+      state.turnRecords.delete(key)
+      removed += 1
+    }
+    state.sessionContextTimes.delete(sid)
+    state.sessionModel.delete(sid)
+    if (removed > 0) markStatsChanged('data')
+    return removed
+  }
   function upsertUsageSample(target, sample, options = {}) {
     const previous = target.get(sample.key)
     const candidate = sample.cost === undefined
-      ? { ...sample, cost: costForUsage(sample.values, sample.identity, options.costPrevious === undefined ? previous : options.costPrevious) }
+      ? { ...sample, cost: costForUsage(sample.values, sample.identity, options.costPrevious === undefined ? previous : options.costPrevious, sample.pricingAt, sample.pricingTimeSource) }
       : sample
     const result = upsertUsageSampleState(target, candidate)
     if (!result.accepted || target !== state.usageByStep || options.materialize === false) return result
@@ -383,7 +417,7 @@ export function createAggregation(host) {
     update(state.byDay.get(dates.local), false)
     update(state.byDayUtc.get(dates.utc), true)
   }
-  function addUsage(wsId, time, usage, model, sid, data, seq, materialization = 'live') {
+  function addUsage(wsId, time, usage, model, sid, data, seq, materialization = 'live', pricingAt, pricingTimeSource) {
     if (!validEventTime(time)) return
     const values = usageValues(usage)
     if (values === null || noValues(values)) return
@@ -405,13 +439,26 @@ export function createAggregation(host) {
       step: data && Number.isSafeInteger(data.step) && data.step >= 0 ? data.step : null,
       materialization,
       sid,
+      ...(pricingAt === undefined ? {} : { pricingAt }),
+      ...(pricingTimeSource === undefined ? {} : { pricingTimeSource }),
     })
   }
-  function addDayTurn(dayMap, date, wsId, sid) {
+  function addDayTurn(dayMap, date, wsId, sid, direction = 1) {
     const day = ensureDay(dayMap, date)
-    adjustDaySession(day, sid, 1)
-    day.turns += 1
-    day.perWs.set(wsId, (day.perWs.get(wsId) || 0) + 1)
+    adjustDaySession(day, sid, direction)
+    day.turns = Math.max(0, day.turns + direction)
+    const next = (day.perWs.get(wsId) || 0) + direction
+    if (next > 0) day.perWs.set(wsId, next)
+    else day.perWs.delete(wsId)
+  }
+  function removeTurnRecord(turn) {
+    const ws = state.perWorkspace.get(turn.wsId)
+    if (ws !== undefined) ws.turns = Math.max(0, ws.turns - 1)
+    state.totals.turns = Math.max(0, state.totals.turns - 1)
+    addDayTurn(state.byDay, turn.date, turn.wsId, turn.sid, -1)
+    addDayTurn(state.byDayUtc, turn.dateUtc, turn.wsId, turn.sid, -1)
+    adjustQueryTurn(state.byDay.get(turn.date), turn, -1, false)
+    adjustQueryTurn(state.byDayUtc.get(turn.dateUtc), turn, -1, true)
   }
   function turnRecordKey(sid, turn, seq, time) {
     if (Number.isSafeInteger(turn)) return sid + ':turn:' + turn
@@ -935,6 +982,7 @@ export function createAggregation(host) {
     usageBasisEqual,
     resolveCurrentPricing,
     costForUsage,
+    removeSession,
     resetAggregationState,
     ensureDay,
     ensureWs,