Class ::nsmcp::AccessScan (public)

 ::nx::Class ::nsmcp::AccessScan[i]

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

Testcases:
No testcase defined.
Source code:
    :public object method empty {} {
        #
        # Return an empty access-log scan accumulator.
        #
        return [dict merge [::nsmcp::accessFailureEmpty] {requestCount 0 statusBelow400Records 0 responseBytes 0 timingCount 0 runTotal 0.0 runMax 0.0 acceptTotal 0.0 queueTotal 0.0 filterTotal 0.0 fallbackCount 0 paths {} methods {} statuses {} pools {} hours {} agents {} peers {} authenticationStates {anonymous 0 authenticated 0 unknown 0} omittedRecords {} unknownUserAgentRecords 0 truncatedUserAgentRecords 0 unknownPeerRecords 0 samples {} successSamples {} parseErrors 0 oversizedRecords 0 pendingRecords 0 examinedRecords 0 earliestAt {} latestAt {}}]
    }

    :public object method progress {publish phase state file {offset {}} {size {}} {completion {}}} {
        #
        # Publish bounded progress for the selected scan phase and source.
        # Omit paths and addresses. Gzip size is unknown until decoding.
        #
        set done 0
        set skipped 0
        set scanned 0
        set pending 0
        foreach entry [dict get $state files] {
            if {[dict get $entry status] eq "complete"} {
                incr done
            }
            if {[dict get $entry status] eq "outside-window"} {
                incr skipped
            }
            if {[dict exists $entry scanStarted]} {
                incr scanned
            }
            if {[dict get $entry status] ni {complete outside-window}} {
                incr pending
            }
        }
        set fields [list phase string $phase updatedAt number [clock seconds]  examinedBytes number [dict get $state examinedBytes] filesCompleted number $done  filesProcessed number [dict get $state index] filesSelected number [llength [dict get $state files]]  filesDiscovered number [llength [dict get $state files]] filesSkipped number $skipped filesScanned number $scanned filesPending number $pending]
        if {[dict exists $state aggregate backend]} {
            lappend fields aggregationBackend string [dict get $state aggregate backend]
            foreach key {poolWaitCount poolWaitMilliseconds poolWaitLimitMilliseconds} {
                if {[dict exists $state aggregate $key]} {
                    lappend fields aggregation[string toupper [string index $key 0]][string range $key 1 end] number [dict get $state aggregate $key]
                }
            }
            if {[dict exists $state aggregate failure] && [dict get $state aggregate failure] ne {}} {
                foreach {key field} {phase aggregationFailurePhase class aggregationFailureClass diagnosticId aggregationDiagnosticId} {
                    lappend fields $field string [dict get $state aggregate failure $key]
                }
            }
            if {[dict get $state aggregate backend] eq "sqlite"} {
                lappend fields aggregationDiskBytes number [dict get $state aggregate diskBytes] aggregationDiskBudgetBytes number [dict get $state aggregate maxBytes]  aggregationStatus string [dict get $state aggregate status]
            }
        }
        if {[dict exists $state selectionProbeBytes]} {
            lappend fields selectionProbeBytes number [dict get $state selectionProbeBytes]
        }
        if {[dict exists $state limits bytes]} {
            lappend fields scanBudgetBytes number [dict get $state limits bytes]
        }
        foreach key {scanStatus completionSummary} {
            if {[dict exists $completion $key]} {
                lappend fields $key string [dict get $completion $key]
            }
        }
        if {[dict exists $completion truncatedByLimits]} {
            lappend fields truncatedByLimits boolean [dict get $completion truncatedByLimits]
        }
        if {$file eq ""} {
            foreach key {currentFileIndex currentFileNumber currentFileSize currentFileOffset currentFileSnapshotBytes} {
                lappend fields $key null {}
            }
            lappend fields offsetBasis string {} currentFileCompressed boolean false
        } else {
            if {$offset eq ""} {
                set offset [dict get $file offset]
            }
            if {[dict exists $file orderedSelection]} {
                set size [expr {[dict exists $file decodedSize] ? [dict get $file decodedSize] : [dict get $file size]}]
                lappend fields selectedFromOffset number [dict get $file scanStart] selectedToOffset number [dict get $file scanEnd]
            }
            if {$size eq "" && $phase ne "decompressing"} {
                if {![dict get $file compressed]} {
                    set size [dict get $file size]
                }
                if {[dict exists $file decodedSize]} {
                    set size [dict get $file decodedSize]
                }
            }
            lappend fields currentFileIndex number [dict get $file fileIndex]  currentFileNumber number [expr {[dict get $file fileIndex]+1}]  currentFileSize [expr {$size eq "" ? "null" : "number"}] $size  currentFileOffset number $offset currentFileSnapshotBytes number [dict get $file size]  currentFileCompressed boolean [dict get $file compressed]  offsetBasis string [expr {[dict get $file compressed] ? "decompressed" : "file"}]
        }
        if {$file ne ""} {
            foreach key {timeIndexSkippedBytes timeIndexValidationBytes} {
                if {[dict exists $file $key]} {
                    lappend fields $key number [dict get $file $key]
                }
            }
        }
        if {$publish ne ""} {
            uplevel #0 [list {*}$publish $fields]
        }
        return $fields
    }

    :public object method sample {row file offset redactor} {
        #
        # Build a redacted request sample with its source offset.
        #
        set sample [list fileIndex number [dict get $file fileIndex] sourceIndex number [dict get $file source] rotation boolean [dict get $file rotation]  offset number $offset offsetBasis string [expr {[dict get $file compressed] ? "decompressed" : "file"}]]
        foreach key {requestIdentifier method status pool authenticationState startTime recordSource driver phaseTimingReason} {
            lappend sample $key [expr {$key in {status startTime} ? "number" : "string"}] [dict get $row $key]
        }
        lappend sample requestIdentifierUnique boolean [dict get $row requestIdentifierUnique] phaseTimingAvailable boolean [dict get $row phaseTimingAvailable]
        # Query strings and user identities are deliberately absent from samples.
        lappend sample path string [$redactor message [string range [dict get $row path] 0 511]]  pathTruncated boolean [expr {[string length [dict get $row path]]>512}]
        if {[dict exists $row userAgent]} {
            lappend sample userAgent string [$redactor message [string range [dict get $row userAgent] 0 511]] userAgentTruncated boolean [expr {[string length [dict get $row userAgent]]>512}]
        }
        return $sample
    }
XQL Not present:
Generic, PostgreSQL, Oracle
[ hide source ] | [ make this the default ]
Show another procedure: