nsmcp::UnifiedAccessAnalytics method retain (public)

 <instance of nsmcp::UnifiedAccessAnalytics> retain

Defined in /usr/local/ns/tcl/nsmcp/log-traffic-unified.tcl

Share the writer gate: maintenance never overlaps ingestion and never waits for a running importer. Readers retain their WAL snapshots.

Testcases:

No testcase defined.

Source code:

set gate nsmcp:unified-writer:[ns_info server]
if {[nsv_incr $gate busy]!=1} {nsv_incr $gate busy -1; return {busy true}}
set key nsmcp:access-retention:[ns_info server]
set token [nsv_incr $key sequence]
set began [clock clicks -milliseconds]; set store {}; set outcome error
set counts {requests 0 diagnostics 0 minutes 0 peers 0}; set batches 0; set code {}
set last [expr {[nsv_exists $key state] ? [dict get [nsv_get $key state] lastRun] : {}}]
nsv_set $key state [dict create token $token running true startedAt [clock seconds] startedTicks $began phaseTicks $began phase open-store deleted $counts lastRun $last]
try {
    set store [accessRecordStoreOpen ${:settings} writer [list ::nsmcp::accessRetentionPhase $token]]
    if {![$store available]} {set outcome pool-busy; return {busy true}}
    while {$batches==0 || [clock clicks -milliseconds]-$began<${:retentionMilliseconds}} {
        accessRetentionPhase $token prune
        set removed [$store prune ${:retentionBatchRows}]
        incr batches; set total 0
        dict for {table n} $removed {dict incr counts $table $n; incr total $n}
        set state [nsv_get $key state]; dict set state deleted $counts; nsv_set $key state $state
        if {$total==0} break
    }
    set outcome ok
    return [dict create deleted $counts batches $batches]
} on error {message options} {
    set code {NSMCP RETENTION operation-failed}
    set candidate [dict get $options -errorcode]
    if {[lrange $candidate 0 1] eq {NSMCP RECORD_STORE} && [regexp {^[a-z][a-z0-9-]{0,63}$} [lindex $candidate 2]]} {set code [lrange $candidate 0 2]}
    ns_log warning "nsmcp: retention cleanup paused ($code); ingestion checkpoints preserved"
    return [dict create failed true code $code]
} finally {
    try {if {$store ne {}} {accessRetentionPhase $token close-store; $store close}} finally {
        set state [nsv_get $key state]
        set last [dict create startedAt [dict get $state startedAt] finishedAt [clock seconds] durationMs [expr {max(0,[clock clicks -milliseconds]-$began)}] outcome $outcome deleted $counts batches $batches]
        if {$code ne {}} {dict set last code $code}
        dict set state running false; dict set state lastRun $last; nsv_set $key state $state
        nsv_incr $gate busy -1
    }
}

XQL Not present:

Generic, PostgreSQL, Oracle