nsmcp::AccessDiagnosticTool method accumulateTraffic (protected)

 <instance of nsmcp::AccessDiagnosticTool> accumulateTraffic \
    stateVar record

Defined in /usr/local/ns/tcl/nsmcp/traffic-tools.tcl

Parameters:

stateVar (required)

record (required)

Testcases:

No testcase defined.

Source code:

upvar 1 $stateVar state
set auth [dict get $record authenticationState]
if {![dict exists $state authenticationStates $auth]} {
    dict set state authenticationStates $auth {requestCount 0 status503Count 0 successfulCount 0 successfulTimingCount 0 successfulRunTotal 0.0}
}
dict incr state requestCount
set status [dict get $record status]
set success [expr {$status>=200 && $status<300}]
set timed [expr {$success && [dict exists $record runTime]}]
set run [expr {$timed ? [dict get $record runTime] : 0.0}]
if {$status==503} {dict incr state status503Count}
if {$success} {dict incr state successfulCount}
if {$timed} {dict incr state successfulTimingCount}
dict set state successfulRunTotal [expr {[dict get $state successfulRunTotal]+$run}]
set authRow [dict get $state authenticationStates $auth]
dict incr authRow requestCount
if {$status==503} {dict incr authRow status503Count}
if {$success} {dict incr authRow successfulCount}
if {$timed} {dict incr authRow successfulTimingCount}
dict set authRow successfulRunTotal [expr {[dict get $authRow successfulRunTotal]+$run}]
dict set state authenticationStates $auth $authRow
set peer [dict get $record peerAddress]
set valid [ns_ip valid $peer]
if {$valid} {
    set peer [ns_crypto::md string -digest sha256 -- [list [dict get $state salt] $peer]]
}
if {!$valid} {
    dict incr state unknownPeerCount
} elseif {![dict exists $state sources $peer] && [dict size [dict get $state sources]]>=${:maxAggregateSources}} {
    dict incr state untrackedSourceRecords
} else {
    set count 0
    if {[dict exists $state sources $peer]} {set count [dict get $state sources $peer]}
    dict set state sources $peer [expr {$count+1}]
}
set ua {}
if {[dict exists $record userAgent]} {set ua [dict get $record userAgent]}
if {$ua in {{} - {[REDACTED]}}} {
    dict incr state unknownUserAgentCount
    return
}
set ua [${:redactor} message $ua]
if {[string length $ua]>2048 || (![dict exists $state agents $ua] && [dict size [dict get $state agents]]>=${:maxAggregateUserAgents})} {
    dict incr state untrackedUserAgentRecords
    return
}
if {![dict exists $state agents $ua]} {
    dict set state agents $ua {requestCount 0 status503Count 0 successfulCount 0 successfulTimingCount 0 successfulRunTotal 0.0}
}
set row [dict get $state agents $ua]
dict incr row requestCount
if {$status==503} {dict incr row status503Count}
if {$success} {dict incr row successfulCount}
if {$timed} {dict incr row successfulTimingCount}
dict set row successfulRunTotal [expr {[dict get $row successfulRunTotal]+$run}]
dict set state agents $ua $row

XQL Not present:

Generic, PostgreSQL, Oracle