nsmcp::LogCorrelation method accessUnifiedReadOnce (private)

 <instance of nsmcp::LogCorrelation> accessUnifiedReadOnce \
    options redactor publish settings

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

Parameters:

options (required)

redactor (required)

publish (required)

settings (required)

Testcases:

No testcase defined.

Source code:

set options [accessFailureOptions [dict merge {includeRotations true selection ordered mode summary maxRecords 5000 maxGroups 20 pathLiteral {}} $options]]
set requested [:dict getdef $options mode "summary"]
set began [clock milliseconds]
accessScanProgress $publish querying-records {files {} index 0 examinedBytes 0} {}
set store [:accessRecordReaderOpen $settings]
try {
    $store allScope
    set overview [$store overview]
    set from [dict get $options from]
    set floor [dict get $overview retentionFloor]
    set fresh [expr {[dict get $options to]<=[dict get $overview updatedAt]+30}]
    set live [expr {$fresh && [dict get $overview cursor]>=[dict get $overview observedSize] && [dict get $overview updatedAt]>0}]
    set history [expr {[dict get $overview historyEnd]>0 && $from<[dict get $overview recentFrom]}]
    set retention [expr {$from<$floor}]
    set writerFailure [nsv_exists nsmcp:access-store:[ns_info server] lastFailure]
    set failureClass {}
    if {$writerFailure} {
        set failureClass [lindex [dict get [nsv_get nsmcp:access-store:[ns_info server] lastFailure] code] 2]
    }
    set capacity [dict get $overview storage]
    set complete [expr {$live && !$history && !$retention && !$writerFailure && ![dict get $capacity limitExceeded] && ![dict get $overview malformed] && ![dict get $overview oversized] && ![dict get $overview pending]}]
    set coverage [list countsCompleteForSnapshots boolean $complete countsAreLowerBounds boolean [expr {!$complete}]  windowComplete boolean false continuousStore boolean true ingestionUpdatedAt number [dict get $overview updatedAt] ingestionLagSeconds number [dict get $overview ingestionLagSeconds]  writerFailure boolean $writerFailure writerFailureClass string $failureClass  storageMaxBytes number [dict get $capacity maxBytes] storageMainMaxBytes number [dict get $capacity mainMaxBytes]  storageMainAllocatedBytes number [dict get $capacity mainAllocatedBytes] storageDiskBytes number [dict get $capacity diskBytes]  storageLimitExceeded boolean [dict get $capacity limitExceeded] storageMinimumBudgetBytes number [dict get $capacity minimumBudgetBytes] sourceCaughtUp boolean $live historicalBackfillPending boolean $history retentionFloor number $floor  retentionSeconds number [dict get $settings retention] peerRetentionSeconds number [dict get $settings peerRetention]  retentionOverlap boolean $retention pendingRecords number [dict get $overview pending] orderingAssumed boolean true]
    if {$requested eq "totals"} {
        lassign [$store totals $options] counts statuses diagnostics
        set fields [list server string [ns_info server] from number $from to number [dict get $options to] timezone string [dict get $options timezone] mode string totals  available boolean true storageConfigured boolean true ingestionPerformed boolean false reason string continuous-store-snapshot]
        set values {}
        dict for {key value} $counts {
            lappend values $key number $value
        }
        lappend fields counts object $values
        set rows {}
        set i 0
        foreach row $statuses {
            lappend rows $i object [list status number [dict get $row status] count number [dict get $row count]]
            incr i
        }
        lappend fields statuses array $rows coverage object $coverage lookupTime object [list wallMs number [expr {[clock milliseconds]-$began}] strategy string [dict get $diagnostics queryStrategy]]
        $store finish
        accessScanProgress $publish complete {files {} index 0 examinedBytes 0} {} {} {} [dict create scanStatus [expr {$complete ? "complete" : "partial"}] completionSummary {Stored totals from the continuous ingestor; coverage describes live lag, backfill and retention.} truncatedByLimits false]
        return [list {} object $fields]
    }
    # Evidence bounds output only in the shared store: counts and rankings
    # concern all stored matching rows, never an arbitrary parsed prefix.
    dict set options mode summary
    lassign [$store stats $options $redactor [accessScanDefaultLimits]] stats aggregate selected
    lassign [$store samples $selected [$store descriptors] $redactor] samples successes
    dict set stats samples $samples
    dict set stats successSamples $successes
    set state [dict create stats $stats files {} index 0 examinedBytes 0 nativeSearch false omittedFiles 0 unavailableFiles 0 ignoredCandidates 0 aggregateResult $aggregate]
    set raw [accessScanResult $state $options [dict merge [accessScanDefaultLimits] [accessAggregateSettings]] $redactor]
    set fields {}
    foreach {key type value} [lindex $raw 2] {
        if {$key in {coverage completionSummary scanStatus scanComplete limitations requestCountScope mode selection orderingAssumed truncatedByLimits limitReasons}} {
            continue
        }
        lappend fields $key $type $value
    }
    lappend fields coverage object $coverage mode string summary requestedMode string $requested selection string stored  orderingAssumed boolean true requestCountScope string retained-stored-window scanStatus string [expr {$complete ? "complete" : "partial"}] scanComplete boolean $complete  truncatedByLimits boolean false limitReasons array {} completionSummary string {SQL snapshot of the continuously populated access store; ingestion lag, backfill and retention qualify counts.}  recordStorage object [list backend string sqlite persistent boolean true continuous boolean true parsedBytesThisJob number 0 diskBytes number [$store diskBytes] maxBytes number [dict get $settings maxBytes]]  limitations string {Counts cover retained committed records. Live ingestion and historical backfill can be incomplete. Raw peer addresses have shorter retention and require explicit authorization. Original source retention is unverified; timestamp-based initial selection assumes approximate ordering. No query reparses the log.}
    $store finish
    accessScanProgress $publish complete {files {} index 0 examinedBytes 0} {} {} {} [dict create scanStatus [expr {$complete ? "complete" : "partial"}] completionSummary {SQL snapshot from the continuous access store; no log was scanned by this question.} truncatedByLimits false]
    return [list {} object $fields]
} finally {
    $store close
}

XQL Not present:

Generic, PostgreSQL, Oracle