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)

previous (required)

interval (required)

instance (required)

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 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 $k] && [dict exists $previous drivers $thread $k]} {
            set d [:delta [dict get $entry $k] [dict get $previous drivers $thread $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}]
    }
}
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