Class ::ns::stats::Collector (public)

 ::nx::Class ::ns::stats::Collector

Defined in

Testcases:

No testcase defined.

Source code:

namespace eval ::ns::stats {}
::nsf::object::alloc ::nx::Class ::ns::stats::Collector {}
::ns::stats::Collector public method describe {{-server {}}} {
        #
        #   Return a dictionary describing the NaviServer process, virtual
        #   servers, connection pools and network drivers. An optional server
        #   argument restricts virtual-server data; process-wide information
        #   retains its process scope. Availability fields identify optional
        #   information that could not be collected.
        #
        #   Does not start sampling or modify the sampling baseline.
        #
        set result [dict create schemaVersion 1 scope process  process [dict create  pid [ns_info pid]  bootTime [ns_info boottime]  version [ns_info patchlevel]  host [ns_info hostname]  uptimeSeconds [ns_info uptime]]  servers {} drivers {} availability {}]

        if {![catch {ns_info buildinfo} build]} {
            dict set result process build $build
        }
        dict set result process platform [dict create  os $::tcl_platform(os)  osVersion $::tcl_platform(osVersion)  machine $::tcl_platform(machine)]
        foreach s [ns_info servers] {
            set pools {}
            foreach p [ns_server -server $s pools] {
                set name [expr {$p eq "" ? "default" : $p}]
                set threads [ns_server -server $s -pool $p threads]
                set limits {}
                foreach k {min max maxconnections} {
                    if {[dict exists $threads $k]} {
                        dict set limits $k [dict get $threads $k]
                    }
                }
                dict set pools $name $limits
            }
            set entry [dict create  pools $pools  databasePools [ns_config ns/server/$s/db pools {}] bindings {} availability {}]
            if {![catch {ns_server -server $s modules} modules]} {
                dict set entry modules $modules
                dict set entry availability modules true
            } else {
                dict set entry availability modules false
            }
            if {![catch {ns_driver info} infos]} {
                foreach driver $infos {
                    set module [dict get $driver module]
                    set mappings {}
                    set allMappings true
                    if {[catch {ns_config -all ns/module/$module/servers $s {}} mappings]} {
                        set mappings [ns_config ns/module/$module/servers $s {}]
                        set allMappings false
                    }
                    if {$mappings ne "" || [dict get $driver server] eq $s} {
                        dict set entry bindings $module [dict create  address [dict get $driver address]  port [dict get $driver port]  protocol [dict get $driver protocol]  hostMappings $mappings  hostMappingsComplete $allMappings]
                    }
                }
            }
            dict set result servers $s $entry
        }

        if {![catch {ns_driver info} info]} {
            set drivers {}
            foreach driver $info {
                set entry {}
                foreach k {
                    module type server location address port defaultport protocol
                    sendwait recvwait recvbufsize sendbufsize libraryversion
                } {
                    if {[dict exists $driver $k]} {
                        dict set entry $k [dict get $driver $k]
                    }
                }
                lappend drivers $entry
            }
            dict set result drivers $drivers
            dict set result availability drivers true
        } else {
            dict set result availability drivers false
        }
        return [:selectServer $result $server]
    }
::ns::stats::Collector protected method selectServer {record server {validate true}} {
        # Restrict virtual-server data; historical records may refer to removed servers.
        if {$server ne ""} {
            if {$validate && $server ni [ns_info servers]} {
                error "unknown server: $server"
            }
            set selected {}
            if {[dict exists $record servers $server]} {
                dict set selected $server [dict get $record servers $server]
            }
            dict set record servers $selected
        }
        return $record
    }
::ns::stats::Collector public method snapshot {{-server {}}} {
        #   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.

        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