ns::stats::Collector method snapshot (public)

 <instance of ns::stats::Collector> snapshot [ -server server ]

Defined in

Collect current gauges, cumulative counters, allocator statistics and thread CPU times into a timestamped dictionary. The timestamp is in epoch microseconds; collectionSeconds records collection duration. The observations are collected sequentially and do not constitute an atomic snapshot of the entire process. An optional server argument restricts virtual-server data. Does not publish a sample or advance the sampling baseline.

Switches:

-server (optional)

Testcases:

No testcase defined.

Source code:

set start [clock microseconds]
set result [dict create  schemaVersion 1  scope process  process [dict create pid [pid] bootTime [ns_info boottime]]  drivers {}  queues {}  servers {}  cpu {}  availability {}  units {time seconds cpuCounter microseconds cpuPercent percentOfOneCore}]
if {![catch {ns_driver stats} stats]} {
    foreach entry $stats {
        dict set result drivers [dict get $entry thread] $entry
    }
    dict set result availability drivers true
} else {
    dict set result availability drivers false
}
foreach kind {driver writer spooler} {
    if {![catch {ns_driver queues $kind} entries]} {
        foreach entry $entries {
            dict set result queues $kind [dict get $entry thread] $entry
        }
        dict set result availability $kind true
    } else {
        dict set result availability $kind false
    }
}
foreach s [ns_info servers] {
    foreach p [ns_server -server $s pools] {
        set name [expr {$p eq "" ? "default" : $p}]
        dict set result servers $s pools $name  [dict create  counters [ns_server -server $s -pool $p stats]  gauges [dict create  threads [ns_server -server $s -pool $p threads]  waitingRequests [ns_server -server $s -pool $p waiting]  activeRequests [llength [ns_server -server $s -pool $p active]]]]
    }
}

set cpu {}
if {![catch {ns_info threadcputimes} times]} {
    foreach t [ns_info threads] {
        set tid [lindex $t 7]
        if {$tid eq "" || ![dict exists $times $tid]} {
            continue
        }
        set identity [list $tid [lindex $t 4]]
        dict set cpu $identity [dict merge [dict get $times $tid] [dict create name [lindex $t 0]]]
    }
}
set memory {}

if {![catch {ns_info meminfo} info]} {
    foreach k {
        current_allocated_bytes heap_size total_physical_bytes slack_bytes
        pageheap_free_bytes pageheap_unmapped_bytes pageheap_committed_bytes
        central_cache_free_bytes transfer_cache_free_bytes thread_cache_free_bytes
        current_total_thread_cache_bytes
    } {
        if {[dict exists $info $k]} {
            dict set memory $k [dict get $info $k]
        }
    }
}
dict set result process allocatorBytes $memory
dict set result availability allocatorMemory [expr {$memory ne ""}]
dict set result cpu $cpu
dict set result availability cpu [expr {$cpu ne ""}]
if {![catch {ns_db stats} dbstats]} {
    dict set result databasePools $dbstats
    dict set result availability databasePools true
} else {
    dict set result availability databasePools false
}
dict set result timestamp [clock microseconds]
dict set result collectionSeconds [expr {([dict get $result timestamp]-$start)/1000000.0}]
return [:selectServer $result $server]

XQL Not present:

Generic, PostgreSQL, Oracle