---

Class ::ns::stats::Collector

::ns::stats::Collector create ...

Defined in

Class Relations

• class: ::nx::Class
• superclass: ::nx::Object
• subclass: ::ns::stats::Sampler

::nx::Class create ::ns::stats::Collector \
     -superclass ::nx::Object

Methods (to be applied on instances)

• describe (scripted, public)

   <instance of ns::stats::Collector> describe [ -server 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.

  Switches:

  -server (optional)

  Testcases:

  No testcase defined.

  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]

• snapshot (scripted, public)

   <instance of ns::stats::Collector> snapshot [ -server 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.

  Switches:

  -server (optional)

  Testcases:

  No testcase defined.

  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]

---