ns::stats::Sampler method calculate (public)

 <instance of ns::stats::Sampler> calculate current previous \
    interval instance

Defined in

Derive interval diagnostics from current and previous snapshots. Return the current observations augmented with counter deltas, rates, average request phase times and thread CPU percentages. Rates use measured elapsed time; interval records the configured sampling cadence, and instance identifies the sampler lifetime. Interval results require a previous snapshot from the same process lifetime and positive elapsed time. Missing baselines or decreased counters yield empty derived values. CPU comparisons match thread identifiers and creation times; percentages use one core as 100%. Does not collect observations or modify shared state.

Parameters:

current (required)

Current snapshot dictionary, including its epoch-microsecond timestamp and process identity.

previous (required)

Previous snapshot dictionary, or empty when no baseline exists.

interval (required)

Configured sampling cadence in seconds; rates use actual elapsed time instead.

instance (required)

Sampler lifetime identifier attached to the calculated sample.

Returns:

Current observations augmented with sampling metadata, counter deltas, rates, average timings and CPU percentages; unavailable derived values remain empty.

Testcases:

No testcase defined.

Source code:

set stamp [dict get $current timestamp]
set elapsed {}
set ready false
set reset false
if {$previous ne ""
    && [dict get $previous process pid] eq [dict get $current process pid]
    && [dict get $previous process bootTime] eq [dict get $current process bootTime]
} {
    set elapsed [expr {($stamp-[dict get $previous timestamp])/1000000.0}]
    if {$elapsed > 0} {
        set ready true
    } else {
        set reset true
    }
}
set result $current
dict set result instance $instance
dict set result sampling [dict create  ready $ready  from {}  to [expr {$stamp/1000000.0}]  elapsedSeconds $elapsed  ageSeconds 0  reset $reset  intervalSeconds $interval]
if {$ready} {
    dict set result sampling from [expr {[dict get $previous timestamp]/1000000.0}]
}

dict for {s server} [dict get $current servers] {
    dict for {p entry} [dict get $server pools] {
        set deltas {}
        set rates {}
        set invalid {}
        dict for {k v} [dict get $entry counters] {
            if {$k ni {requests queued spools spooled dropped queuetime filtertime runtime tracetime}} {
                continue
            }
            set d {}
            if {$ready && [dict exists $previous servers $s pools $p counters $k]} {
                set d [:delta $v [dict get $previous servers $s pools $p counters $k]]
                if {$d eq ""} {
                    lappend invalid $k
                }
            }
            dict set deltas $k $d
            dict set rates $k [expr {$d eq "" ? "" : $d/$elapsed}]
        }
        dict set result servers $s pools $p deltas $deltas
        dict set result servers $s pools $p rates $rates
        dict set result servers $s pools $p resetCounters $invalid
        set timings {}
        set n [expr {[dict exists $deltas requests] ? [dict get $deltas requests] : ""}]

        foreach k {queuetime filtertime runtime tracetime} {
            set d [expr {[dict exists $deltas $k] ? [dict get $deltas $k] : ""}]
            dict set timings $k [expr {$n eq "" || $n == 0 || $d eq "" ? "" : $d/$n}]
        }
        dict set result servers $s pools $p timingAverageSeconds $timings
    }
}

dict for {thread entry} [dict get $current drivers] {
    set deltas {}
    set rates {}
    set invalid {}
    foreach k {received partial spooled errors} {
        set d {}
        if {$ready && [dict exists $entry counters $k] && [dict exists $previous drivers $thread counters $k]} {
            set d [:delta [dict get $entry counters $k] [dict get $previous drivers $thread counters $k]]
            if {$d eq ""} {
                lappend invalid $k
            }
        }
        dict set deltas $k $d
        dict set rates $k [expr {$d eq "" ? "" : $d/$elapsed}]
    }
    dict set result drivers $thread deltas $deltas
    dict set result drivers $thread rates $rates
    dict set result drivers $thread resetCounters $invalid
}

set percentages {}
set totals {}
set matched 0

dict for {id entry} [dict get $current cpu] {
    set percent {}
    if {$ready && [dict exists $previous cpu $id]} {
        set old [dict get $previous cpu $id]
        set user [:delta [dict get $entry user] [dict get $old user]]
        set system [:delta [dict get $entry system] [dict get $old system]]
        if {$user ne "" && $system ne ""} {
            set percent [expr {100.0*($user+$system)/($elapsed*1000000)}]
            incr matched
        }
    }
    set name [string trim [dict get $entry name] -]
    set group other
    foreach {pattern kind} {driver:* driver conn:* connection writer:* writer spooler:* spooler} {
        if {[string match $pattern $name]} {
            set group $kind
            break
        }
    }
    dict set percentages $id [dict create name $name group $group percent $percent]
    if {$percent ne ""} {
        set total [expr {[dict exists $totals $group] ? [dict get $totals $group] : 0.0}]
        dict set totals $group [expr {$total+$percent}]
    }
}
if {[dict exists $current process cpuCapacity throttling]} {
    dict for {path row} [dict get $current process cpuCapacity throttling] {
        foreach field {periods throttledPeriods throttledSeconds} {
            set delta {}
            if {$ready && [dict exists $row $field] && [dict exists $previous process cpuCapacity throttling $path $field]} {
                set old [dict get $previous process cpuCapacity throttling $path $field]
                if {[dict get $row $field]>=$old} {set delta [expr {[dict get $row $field]-$old}]}
            }
            dict set row delta[string toupper [string index $field 0]][string range $field 1 end] $delta
        }
        dict set row throttledPeriodPercent {}
        if {[dict get $row deltaPeriods] ne "" && [dict get $row deltaPeriods]>0 && [dict get $row deltaThrottledPeriods] ne ""} {
            dict set row throttledPeriodPercent [expr {100.0*[dict get $row deltaThrottledPeriods]/[dict get $row deltaPeriods]}]
        }
        dict set result process cpuCapacity throttling $path $row
    }
}
dict set result cpuPercent [dict create  scope process  matchedThreads $matched  observedThreads [dict size [dict get $current cpu]]  groups $totals  threads $percentages]
return $result

XQL Not present:

Generic, PostgreSQL, Oracle