Class ::nsmcp::AccessScan

::nsmcp::AccessScan[i] create ...

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

Class Relations

  • class: ::nx::Class[i]
  • superclass: ::nsmcp::Object[i]
::nx::Class create ::nsmcp::AccessScan \
     -superclass ::nsmcp::Object

Methods (to be applied on the object)

  • empty (scripted, public)

     nsmcp::AccessScan[i] empty

    Return an empty access-log scan accumulator.

    Testcases:
    No testcase defined.
    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 {}}]
  • progress (scripted, public)

     nsmcp::AccessScan[i] 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.

    Parameters:
    publish (required)
    phase (required)
    state (required)
    file (required)
    offset (optional)
    size (optional)
    completion (optional)

    Testcases:
    No testcase defined.
    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
  • sample (scripted, public)

     nsmcp::AccessScan[i] sample row file offset redactor

    Build a redacted request sample with its source offset.

    Parameters:
    row (required)
    file (required)
    offset (required)
    redactor (required)

    Testcases:
    No testcase defined.
    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