ns::stats::Sampler method sampling history (public)

 <instance of ns::stats::Sampler> sampling history -from from  \
    -to to  [ -server server ] [ -limit limit ] [ -cursor cursor ]

Defined in

Read the bounded process-wide recent sample buffer without SQLite. Retains at most 180 compact samples and 15 minutes at publication. Returns interval metrics, coverage and timestamp-based paging. Raw/per-thread CPU counters are omitted. Reading does not collect, start sampling, advance baselines or write persistent history. The buffer survives sampler stop/start but not a process restart.

Switches:

-from (required, integer)

-to (required, integer)

-server (optional)

-limit (optional, integer, defaults to "180")

-cursor (optional, integer, defaults to "0")

Testcases:

No testcase defined.

Source code:

if {$from<0 || $to<=$from || $to-$from>86400 || $to>[clock seconds]
    || $limit<1 || $limit>180 || $cursor<0} {
    error "expected an epoch window up to 24 hours, limit 1..180 and nonnegative cursor"
}
if {[string length $server]>512 || [string first \x00 $server]>=0} {
    error "invalid server name"
}
:locked {
    set retained [nsv_get ns_stats recent]
    set dropped [nsv_get ns_stats recentDroppedThrough]
}
set records {}
set gaps {}
set restarts {}
set resets 0
set previous {}
set first {}
set last {}
set more false
foreach record $retained {
    set stamp [dict get $record timestamp]
    if {$first eq ""} {
        set first $stamp
    }
    set last $stamp
    if {$stamp<$from*1000000 || $stamp<=$cursor} {
        set previous $record
        continue
    }
    if {$stamp>=$to*1000000} {
        # A gap crossing the upper bound must not certify coverage.
        if {$previous ne ""} {
            set delta [expr {($stamp-[dict get $previous timestamp])/1000000.0}]
            if {$delta>1.5*max([dict get $previous sampling intervalSeconds],
                               [dict get $record sampling intervalSeconds])} {
                lappend gaps [dict create from [dict get $previous sampling to] to [dict get $record sampling to]]
            }
        }
        break
    }
    if {[llength $records]>=$limit} {
        set more true
        break
    }
    if {![dict get $record sampling ready]} {
        incr resets
    }
    if {$previous ne ""} {
        if {[dict get $previous instance] ne [dict get $record instance]} {
            lappend restarts [dict get $record sampling to]
        }
        set delta [expr {($stamp-[dict get $previous timestamp])/1000000.0}]
        if {$delta>1.5*max([dict get $previous sampling intervalSeconds],
                           [dict get $record sampling intervalSeconds])} {
            lappend gaps [dict create from [dict get $previous sampling to] to [dict get $record sampling to]]
        }
    }
    lappend records [:selectServer [dict remove $record cpu] $server false]
    set previous $record
}
# Retained bounds refer to the buffer, independently of the selected page.
if {$retained ne ""} {
    set first [dict get [lindex $retained 0] timestamp]
    set last [dict get [lindex $retained end] timestamp]
}
set overlap [expr {$dropped ne "" && $dropped>=$from*1000000}]
if {!$more && $cursor>0} {
    set window [:sampling history -from $from -to $to -server $server -limit 180]
    set coverage [dict get $window coverage]
    return [dict create schemaVersion 1 source memory from $from to $to records $records  nextCursor {} more false retentionSeconds 900 maxSamples 180 coverage $coverage]
}
set complete [expr {$first ne "" && $first<=$from*1000000 && $last>=$to*1000000
                     && !$more && $cursor==0 && !$overlap && $gaps eq ""
                     && $restarts eq "" && $resets==0}]
set next {}
if {$more} {
    set next [dict get [lindex $records end] timestamp]
}
return [dict create schemaVersion 1 source memory from $from to $to records $records  nextCursor $next more $more retentionSeconds 900 maxSamples 180  coverage [dict create complete $complete windowExamined [expr {!$more && $cursor==0}]  retainedFrom [expr {$first eq "" ? 0 : $first/1000000.0}]  retainedTo [expr {$last eq "" ? 0 : $last/1000000.0}]  gaps $gaps restartBoundaries $restarts resetSamples $resets  evictionOrFailureOverlap $overlap droppedThrough $dropped]]

XQL Not present:

Generic, PostgreSQL, Oracle