nsmcp::AccessRecordSupport method accessRecordTotalsOnce (protected)

 <instance of nsmcp::AccessRecordSupport> accessRecordTotalsOnce \
    paths options redactor limits publish settings

Defined in /usr/local/ns/tcl/nsmcp/log-traffic-record-00-support.tcl

Parameters:

paths (required)

options (required)

redactor (required)

limits (required)

publish (required)

settings (required)

Testcases:

No testcase defined.

Source code:

set began [clock milliseconds]
set fields [list server string [ns_info server] mode string totals from number [dict get $options from] to number [dict get $options to] timezone string [dict get $options timezone] ingestionPerformed boolean false storageConfigured boolean [expr {$settings ne {}}]]
set baseFields $fields
if {$settings eq {}} {
    accessScanProgress $publish complete {files {} index 0 examinedBytes 0} {} {} {} [dict create scanStatus partial completionSummary {Stored totals unavailable: persistent record storage is not configured. No log import was started.} truncatedByLimits false]
    lappend fields available boolean false reason string record-store-not-configured counts null {} coverage object [list countsCompleteForSnapshots boolean false windowComplete boolean false] lookupTime object [list wallMs number [expr {[clock milliseconds]-$began}] scope string stored-totals-lookup]
    return [list {} object $fields]
}
set policy [list schema1 [::nsmcp::accessRecordParser cget -timingColumn]]
foreach key {queryParameters headerNames maskPeerAddresses maskUserIdentifiers replacement} {
    lappend policy [$redactor cget -$key]
}
dict set settings policy $policy
set configured [:dict getdef $options scanLimits {}]
set limits [dict merge [accessScanDefaultLimits] [accessAggregateSettings] $configured $limits]
set state [accessScanDiscover $paths [dict get $options includeRotations] [dict get $limits files]]
dict set state stats [accessScanEmpty]
dict set state index 0
dict set state examinedBytes 0
accessScanProgress $publish checking-stored-totals $state {}
set store {}
set scopes {}
set sourceFiles {}
set complete true
set compressed 0
set pending 0
set totalBytes 0
set storedBytes 0
set skipped 0
try {
    set store [:accessRecordReaderOpen $settings]
    if {![$store available]} {
        accessScanProgress $publish complete $state {} {} {} [dict create scanStatus partial completionSummary {Stored totals unavailable: record pool is busy. No log import was started.} truncatedByLimits false]
        lappend fields available boolean false reason string record-store-pool-busy counts null {} coverage object [list countsCompleteForSnapshots boolean false windowComplete boolean false]
        return [list {} object $fields]
    }
    foreach file [dict get $state files] {
        accessScanUnchanged $file
        if {[dict get $file compressed]} {
            dict set file status unsupported-compressed-source
            dict set state files [lreplace [dict get $state files] [dict get $file fileIndex] [dict get $file fileIndex] $file]
            incr compressed
            set complete false
            lappend sourceFiles [list fileIndex [dict get $file fileIndex] status unsupported-compressed-source snapshotBytes [dict get $file size]]
            continue
        }
        if {[accessOrderedEnabled $options]} {
            accessOrderedPlan file state $options $limits $publish
        }
        if {[dict get $file status] eq "outside-window"} {
            dict set state files [lreplace [dict get $state files] [dict get $file fileIndex] [dict get $file fileIndex] $file]
            incr skipped
            continue
        }
        set fid [$store prepare $file]
        if {$fid<0} {
            set fid [expr {-[dict get $file fileIndex]-1}]
        }
        set lo [dict get $file offset]
        set hi [expr {[dict exists $file scanEnd] ? [dict get $file scanEnd] : [dict get $file size]}]
        dict set file archiveFid $fid
        dict set file archiveLo $lo
        dict set file offset $hi
        lappend scopes $file
        incr totalBytes [expr {$hi-$lo}]
    }
    # Counts and committed-range coverage share a single read transaction.
    $store scope $scopes
    foreach file $scopes {
        accessScanUnchanged $file
        set lo [dict get $file archiveLo]
        set hi [dict get $file offset]
        set covered [$store coveredBytes [dict get $file archiveFid] $lo $hi]
        incr storedBytes $covered
        dict set file status [expr {$covered==$hi-$lo ? "complete" : "not-ingested"}]
        dict set state files [lreplace [dict get $state files] [dict get $file fileIndex] [dict get $file fileIndex] $file]
        if {$covered!=$hi-$lo} {
            set complete false
            incr pending
        }
        lappend sourceFiles [list fileIndex [dict get $file fileIndex] status [expr {$covered==$hi-$lo ? "stored" : "not-fully-ingested"}] snapshotBytes [dict get $file size] selectedBytes [expr {$hi-$lo}] storedBytes $covered missingBytes [expr {$hi-$lo-$covered}]]
    }
    lassign [$store totals $options] counts statuses diagnostics
    foreach file $scopes {
        accessScanUnchanged $file
    }
    if {[dict get $state omittedFiles] || [dict get $state unavailableFiles]} {
        set complete false
    }
    set rangesComplete $complete
    if {[dict get $diagnostics parseErrors] || [dict get $diagnostics oversizedRecords] || [dict get $diagnostics pendingRecords] || ![:dict getdef $diagnostics diagnosticCountsComplete true]} {
        set complete false
    }
    set countFields {}
    dict for {key value} $counts {
        lappend countFields $key number $value
    }
    set statusFields {}
    set i 0
    foreach row $statuses {
        lappend statusFields $i object [list status number [dict get $row status] count number [dict get $row count]]
        incr i
    }
    set files {}
    set i 0
    foreach row $sourceFiles {
        set rowFields {}
        foreach {key value} $row {
            lappend rowFields $key [expr {$key eq "status" ? "string" : "number"}] $value
        }
        lappend files $i object $rowFields
        incr i
    }
    set coverage [list countsCompleteForSnapshots boolean $complete sourceRangesFullyIngested boolean $rangesComplete countsAreLowerBounds boolean [expr {!$complete}]  diagnosticCountsComplete boolean [:dict getdef $diagnostics diagnosticCountsComplete true] windowComplete boolean false orderingAssumed boolean [accessOrderedEnabled $options] files array $files  filesDiscovered number [llength [dict get $state files]] filesSkippedOutsideWindow number $skipped filesMissingIngestion number $pending  compressedFilesUnsupported number $compressed omittedFiles number [dict get $state omittedFiles] unavailableFiles number [dict get $state unavailableFiles]  selectedSourceBytes number $totalBytes storedSourceBytes number $storedBytes missingSourceBytes number [expr {$totalBytes-$storedBytes}]  retentionVerified boolean false]
    dict for {key value} $diagnostics {
        lappend coverage $key [expr {$key eq "queryStrategy" ? "string" : "number"}] $value
    }
    lappend fields available boolean true reason string [expr {$complete ? "validated-stored-snapshot-totals" : "stored-prefix-or-partial-ranges-only"}]  counts object $countFields statuses array $statusFields coverage object $coverage  originDetailsIncluded boolean false countsScope string {Stored matching access records only. Missing ingestion, parse diagnostics, unsupported compressed files, ordered selection and unverified retention qualify these counts. No daily extrapolation.}  lookupTime object [list wallMs number [expr {[clock milliseconds]-$began}] scope string stored-totals-lookup]
    $store finish
    accessScanProgress $publish complete $state {} {} {} [dict create scanStatus [expr {$complete ? "complete" : "partial"}] completionSummary [expr {$complete ? "Stored totals cover the selected source snapshots; retention remains unverified." : "Stored totals are incomplete: missing ingestion or source/parse limitations; no log import was started."}] truncatedByLimits false]
    return [list {} object $fields]
} on error {message opts} {
    if {[regexp -nocase {database.*(locked|busy)} $message] || [lindex [dict get $opts -errorcode] 2] in {database-locked database-busy pool-busy}} {
        return -options $opts $message
    }
    if {[lrange [dict get $opts -errorcode] 0 1] eq {NSMCP RECORD_STORE}} {
        set kind [lindex [dict get $opts -errorcode] 2]
        set id [lindex [dict get $opts -errorcode] 3]
    } else {
        if {$store ne {}} {
            set failure [$store diagnostic $message $opts]
        } else {
            set failure [accessAggregationDiagnostic record-store $message $opts]
        }
        set kind [dict get $failure class]
        set id [dict get $failure diagnosticId]
    }
    set fields $baseFields
    accessScanProgress $publish complete  $state {} {} {}  [dict create scanStatus partial completionSummary "Stored totals unavailable ($kind). No log import was started." truncatedByLimits false]
    lappend fields available boolean false reason string record-store-$kind counts null {}  diagnostic object [list class string $kind id string $id]  coverage object [list countsCompleteForSnapshots boolean false windowComplete boolean false]  lookupTime object [list wallMs number [expr {[clock milliseconds]-$began}] scope string stored-totals-lookup]
    return [list {} object $fields]
} finally {
    if {$store ne {}} {
        $store close
    }
}

XQL Not present:

Generic, PostgreSQL, Oracle