nsmcp::AccessCardinalityStore method results (public)

 <instance of nsmcp::AccessCardinalityStore> results limit \
    expectedPeers expectedAgents

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

Build bounded peer and agent cardinality evidence. Flush observations and compare observed diversity with expected counts to report lower bounds and omissions.

Parameters:

limit (required)

Maximum number of records or entries to return.

expectedPeers (required)

Expected peer observation count used to assess completeness.

expectedAgents (required)

Expected user-agent observation count used to assess completeness.

Returns:

The cardinality result dictionary.

Testcases:

No testcase defined.

Source code:

:flush
set result [dict create backend sqlite status [dict get ${:data} status] reason [dict get ${:data} reason]  maxBytes [dict get ${:data} maxBytes] diskBytes [:diskBytes] peakBufferedKeys [:dict getdef ${:data} peakBufferedKeys 0] peerOmitted [dict get ${:data} peerOmitted] agentOmitted [dict get ${:data} agentOmitted]  labelTruncatedRecords [dict get ${:data} labelTruncatedRecords] labelRedactedRecords [dict get ${:data} labelRedactedRecords]]
foreach key {failure poolWaitCount poolWaitMilliseconds poolWaitLimitMilliseconds} {
    dict set result $key [dict get ${:data} $key]
}
foreach {field kind} {peers 0 agents 1} {
    set rows {}
    set totals [dict create distinct 0 records 0 top1 0 top10 0 top100 0 rankedRecords 0 clippedRecords 0 redactedRecords 0]
    if {${:db} ne "" && [catch {
        ${:db} execute -arrayName r -script {
            dict set totals distinct $r(distinctCount)
            dict set totals records $r(records)
            dict set totals clippedRecords $r(clippedRecords)
            dict set totals redactedRecords $r(redactedRecords)
        } "SELECT count(*) AS distinctCount,coalesce(sum(n),0) AS records,coalesce(sum(n*clipped),0) AS clippedRecords,coalesce(sum(n*redacted),0) AS redactedRecords FROM nsmcp_access_aggregate.counts WHERE kind=$kind"
        set i 0
        ${:db} execute -arrayName r -script {
            incr i
            if {$i==1} {
                dict set totals top1 $r(n)
            }
            if {$i<=10} {
                dict incr totals top10 $r(n)
            }
            dict incr totals top100 $r(n)
            if {$i<=$limit} {
                dict incr totals rankedRecords $r(n)
                lappend rows [dict create value $r(label) count $r(n) valueTruncated $r(clipped) valueRedacted $r(redacted)]
            }
        } "SELECT label,clipped,redacted,n FROM nsmcp_access_aggregate.counts WHERE kind=$kind ORDER BY n DESC,k LIMIT 100"
    } readError readOptions]} {
        :fail read-results sqlite-read-failed $readError $readOptions
        foreach key {status reason failure} {
            dict set result $key [dict get ${:data} $key]
        }
        set rows {}
        set totals {distinct 0 records 0 top1 0 top10 0 top100 0 rankedRecords 0 clippedRecords 0 redactedRecords 0}
        :disconnect true
    }
    dict set result $field $rows
    dict set result ${field}Totals $totals
}
dict set result labelTruncatedRecords [dict get $result agentsTotals clippedRecords]
dict set result labelRedactedRecords [dict get $result agentsTotals redactedRecords]
if {[dict get $result peersTotals records]+[dict get $result peerOmitted]!=$expectedPeers
    || [dict get $result agentsTotals records]+[dict get $result agentOmitted]!=$expectedAgents} {
    if {[dict get $result status] ne "unavailable"} {
        dict set result reason aggregation-count-mismatch
    }
    dict set result status unavailable
    foreach {field expected omitted} [list peers $expectedPeers peerOmitted agents $expectedAgents agentOmitted] {
        dict set result $field {}
        dict set result ${field}Totals {distinct 0 records 0 top1 0 top10 0 top100 0 rankedRecords 0 clippedRecords 0 redactedRecords 0}
        dict set result $omitted $expected
    }
}
return $result

XQL Not present:

Generic, PostgreSQL, Oracle