nsmcp::AccessRecordStoreSQLite method tuple (public)

 <instance of nsmcp::AccessRecordStoreSQLite> tuple fid off stop \
    kind row redactor file [ batched ]

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

Construct one policy-processed record from a valid parsed request. Redact display fields and encode the canonical row representation. Cache completion-time parsing and retain eligible peer-address observations for the enclosing ingestion transaction; do not insert a row here.

Parameters:

fid (required)

Stored source-file identifier.

off (required)

Starting source byte offset.

stop (required)

Exclusive byte offset after the record.

kind (required)

Record kind; only valid requests (zero) are accepted.

row (required)

Parsed request dictionary.

redactor (required)

Redaction object for display fields.

file (required)

Source descriptor used to derive the stable sample identifier.

batched (optional, defaults to "false")

True to return a prepared row; false to return a quoted SQL tuple.

Returns:

The cooked request as a Tcl row list or serialized SQL tuple.

Testcases:

No testcase defined.

Source code:

if {$kind!=0} {
    error "only parsed requests have tuples"
}
set values [list $fid $off $stop $kind]
set peer [dict get $row peerAddress]
set agent [:dict getdef $row userAgent {}]
set peerBinary [expr  {$peer in {{} - {[REDACTED]}} ? {} : [ns_crypto::md string -digest sha256 -encoding binary -- $peer]}]
set peer [binary encode hex $peerBinary]
set key [expr {$agent in {{} -} ? {} : [ns_crypto::md string -digest sha256 -- $agent]}]
set label [$redactor message $agent]
set clipped [expr {
                   [string length [encoding convertto utf-8 $label]]>1024 ||
                   [string length [encoding convertto utf-8 $agent]]>1024
               }]
set redacted [expr {$label ne $agent}]
if {$clipped} {
    set label  [encoding convertfrom utf-8 [string range [encoding convertto utf-8 $label] 0 1023]]
    while {[string length [encoding convertto utf-8 $label]]>1024} {
        set label [string range $label 0 end-1]
    }
}
foreach k  {startTime status path method pool recordSource driver authenticationState responseBytes phaseTimingAvailable} {
    lappend values [dict get $row $k]
}
lappend values [expr {[dict get $row timingSource] eq "completion"}]
foreach k {acceptTime queueTime filterTime runTime} {
    lappend values [:dict getdef $row $k 0.0]
}
lappend values $peer $key $label $clipped $redacted [dict get $row requestIdentifier]  [ns_crypto::md string -digest sha256 -- [list [dict get $file identity] $off]]
set completed 0
if {$kind==0} {
    set stamp [dict get $row timestamp]
    if {$stamp ne ${:lastStamp}} {
        set :lastStamp $stamp
        if {[string is entier -strict $stamp]} {
            set :lastCompleted $stamp
        } elseif {[catch {
            clock scan $stamp -format {%d/%b/%Y:%H:%M:%S %z} -locale C
        } value]} {
            set :lastCompleted 0
        } else {
            set :lastCompleted $value
        }
    }
    set completed ${:lastCompleted}
    if {[:dict getdef ${:settings} unified false]} {
        set address [dict get $row peerAddress]
        set time [dict get $row startTime]
        if {
            [ns_ip valid $address] && $time>=[clock seconds]-[dict get ${:settings} peerRetention] &&
            $time<=[clock seconds]+60
        } {
            dict set :peers $peerBinary [list $address $time]
        }
    }
}
lappend values $completed 1
if {$batched} {
    return $values
}
# Hash columns retain BLOB storage; absent peer/agent hashes retain
# empty TEXT. Quote each contiguous scalar group in one core call.
set sql [ns_dbquotelist [lrange $values 0 18]]
foreach index {19 20} {
    set hash [lindex $values $index]
    if {$hash eq {}} {
        append sql ",''"
    } else {
        append sql ",X[ns_dbquotevalue $hash]"
    }
}
append sql , [ns_dbquotelist [lrange $values 21 24]]
append sql ,X [ns_dbquotevalue [lindex $values 25]]
append sql , [ns_dbquotelist [lrange $values 26 27]]
set result "($sql)"
if {${:partitionInterval}>0} {
    dict set :tupleTimes $result [dict get $row startTime]
}
return $result

XQL Not present:

Generic, PostgreSQL, Oracle