nsmcp::AccessRecordParser method fields (public)

 <instance of nsmcp::AccessRecordParser> fields peer identifier \
    user stamp request status bytes tail [ scannedFields ]

Defined in /usr/local/ns/tcl/nsmcp/access-record.tcl

Parameters:

peer (required)

identifier (required)

user (required)

stamp (required)

request (required)

status (required)

bytes (required)

tail (required)

scannedFields (optional)

Testcases:

No testcase defined.

Source code:

if {![regexp {^[1-5][0-9]{2}$} $status]} {return {}}
set user [string trim $user {"}]
set authenticationState [expr {$user in {0 -} ? "anonymous" : ($user in {{} {[REDACTED]}} ? "unknown" : "authenticated")}]
set timestamp [string trim $stamp {[]}]
set result [dict create authenticationState $authenticationState timestamp $timestamp peerAddress $peer requestIdentifier {} pool unknown method unknown url {} status [scan $status %d] responseBytes 0 timingSource completion]
if {$bytes ne "-"} {dict set result responseBytes [scan $bytes %lld]}
if {[::nsmcp::logRecordParser validRequestIdentifier $identifier]} {
    dict set result requestIdentifier $identifier
}
set result [dict merge $result [::nsmcp::accessRecordIdentity $identifier]]
if {[dict get $result recordSource] eq "driver"} {
    # Request authentication was not performed by an application worker.
    dict set result authenticationState unknown
}
# Empty/binary/probe requests remain valid access records. Extract the
# ends of a request line, allowing embedded spaces in the logged target.
set first [string first " " $request]
set last [string last " " $request]
if {$first>0 && $last>$first} {
    set protocol [string range $request [expr {$last+1}] end]
    if {[string match */* $protocol]} {
        dict set result method [string range $request 0 [expr {$first-1}]]
        dict set result url [string range $request [expr {$first+1}] [expr {$last-1}]]
        dict set result protocol $protocol
    }
} elseif {[string match /* $request]} {
    dict set result url $request
}
set fields $scannedFields
if {$fields eq {}} {set fields [regexp -all -inline {"(?:[^"\\]|\\.)*"} $tail]}
# Combined access format has referer and User-Agent as its first two
# quoted fields. Common format has no User-Agent; leave it unknown.
if {[llength $fields]>=2 && ${:timingColumn} in {-2 -1 2}} {
    dict set result userAgent [string range [lindex $fields 1] 1 end-1]
}
set timing [:timingFields $timestamp $fields]
if {$timing eq ""} {return {}}
set result [dict merge $result $timing]
set available [expr {[dict get $timing timingSource] eq "start" && [dict get $result recordSource] ne "driver"}]
dict set result phaseTimingAvailable $available
dict set result phaseTimingReason [expr {$available ? "logged-worker-phases" : ([dict get $result recordSource] eq "driver" ? "driver-synthetic-phases" : "no-phase-counters")}]
if {!$available} {foreach key {acceptTime queueTime filterTime runTime} {dict unset result $key}}
set path [lindex [split [dict get $result url] ?] 0]
if {[regexp {^[A-Za-z][A-Za-z0-9+.-]*://[^/]*(/.*)?$} $path -> suffix]} {
    set path [expr {$suffix eq "" ? "/" : $suffix}]
}
dict set result path $path
return $result

XQL Not present:

Generic, PostgreSQL, Oracle