0/dfstat.py

These stats are similar to ones provided by /usr/bin/df util.

• df.bytes.total

  total size of data

• df.bytes.used

  bytes used

• df.bytes.free

  bytes free

• df.inodes.total

  total number of inodes

• df.inodes.used

  number of inodes used

• df.inodes.free

  number of inodes free

These metrics include time series tagged with each mount point and the filesystem's fstype. This collector filters out any cgroup, debugfs, devtmpfs, rpc_pipefs, rootfs filesystems, as well as any any mountpoints mounted under /dev/, /sys/, /proc/, and /lib/.

With these tags you can select to graph just a specific filesystem, or all filesystems with a particular fstype (e.g. ext3).

0/ifstat.py

These stats are from /proc/net/dev.

• proc.net.bytes

  (rate) Bytes in/out

• proc.net.packets

  (rate) Packets in/out

• proc.net.errs

  (rate) Packet errors in/out

• proc.net.dropped

  (rate) Dropped packets in/out

These are interface counters, tagged with the interface, iface=, and direction= in or out. Only ethN interfaces are tracked. We intentionally exclude bondN interfaces, because bonded interfaces still keep counters on their child ethN interfaces and we don't want to double-count a box's network traffic if you don't select on iface=.

0/iostat.py

Data is from /proc/diskstats.

• iostat.disk.*

  per-disk stats

• iostat.part.*

  per-partition stats (see note below on different metrics, depending on if you have a 2.6 kernel before 2.6.25 or after.)

See iostats.txt

/proc/diskstats has 11 stats for a given physical device. These are all rate counters, except ios_in_progress.

.read_requests       Number of reads completed
.read_merged         Number of reads merged
.read_sectors        Number of sectors read
.msec_read           Time in msec spent reading
.write_requests      Number of writes completed
.write_merged        Number of writes merged
.write_sectors       Number of sectors written
.msec_write          Time in msec spent writing
.ios_in_progress     Number of I/O operations in progress
.msec_total          Time in msec doing I/O
.msec_weighted_total Weighted time doing I/O (multiplied by ios_in_progress)

in 2.6.25 and later, by-partition stats are reported the same as disks.

.read_issued
.read_sectors
.write_issued
.write_sectors

For partitions, these *_issued are counters collected before requests are merged, so aren't the same as *_requests (which is post-merge, which more closely represents represents the actual number of disk transactions).

Given that diskstats provides both per-disk and per-partition data, for TSDB purposes we put them under different metrics (versus the same metric and different tags). Otherwise, if you look at a given metric, the data for a given box will be double-counted, since a given operation will increment both the disk series and the partition series. To fix this, we output by-disk data to iostat.disk.* and by-partition data to iostat.part.*.

0/netstat.py

Socket allocation and network statistics.

Metrics from /proc/net/sockstat.

• net.sockstat.num_sockets

  Number of sockets allocated (only TCP)

• net.sockstat.num_timewait

  Number of TCP sockets currently in TIME_WAIT state

• net.sockstat.sockets_inuse

  Number of sockets in use (TCP/UDP/raw)

• net.sockstat.num_orphans

  Number of orphan TCP sockets (not attached to any file descriptor)

• net.sockstat.memory

  Memory allocated for this socket type (in bytes)

• net.sockstat.ipfragqueues

  Number of IP flows for which there are currently fragments queued for reassembly

Metrics from /proc/net/netstat (netstat -s command).

• net.stat.tcp.abort

  Number of connections that the kernel had to abort. <code>type=memory</code> is especially bad, the kernel had to drop a connection due to having too many orphaned sockets. Other types are normal (e.g. timeout)

• net.stat.tcp.abort.failed

  Number of times the kernel failed to abort a connection because it didn't even have enough memory to reset it (bad)

• net.stat.tcp.congestion.recovery

  Number of times the kernel detected spurious retransmits and was able to recover part or all of the CWND

• net.stat.tcp.delayedack

  Number of delayed ACKs sent of different types.

• net.stat.tcp.failed_accept

  Number of times a connection had to be dropped after the 3WHS. reason=full_acceptq indicates that the application isn't accepting connections fast enough. You should see SYN cookies too

• net.stat.tcp.invalid_sack

  Number of invalid SACKs we saw of diff types. (requires Linux v2.6.24-rc1 or newer)

• net.stat.tcp.memory.pressure

  Number of times a socket entered the "memory pressure" mode (not great).

• net.stat.tcp.memory.prune

  Number of times a socket had to discard received data due to low memory conditions (bad)

• net.stat.tcp.packetloss.recovery

  Number of times we recovered from packet loss by type of recovery (e.g. fast retransmit vs SACK)

• net.stat.tcp.receive.queue.full

  Number of times a received packet had to be dropped because the socket's receive queue was full. (requires Linux v2.6.34-rc2 or newer)

• net.stat.tcp.reording

  Number of times we detected re-ordering and how

• net.stat.tcp.syncookies

  SYN cookies (both sent &amp; received)

0/nfsstat.py

These stats are from /proc/net/rpc/nfs.

• nfs.client.rpc.stats

  RPC stats counter

It tagged with the type (<code>type=</code>) of operation. There are 3 operations: authrefrsh - number of times the authentication information refreshed, calls - number of calls conducted, and retrans - number of retransmissions

• nfs.client.rpc

  RPC calls counter

It tagged with the version (version=) of NFS server that conducted the operation, and name of operation (op=)

Description of operations can be found at appropriate RFC: NFS ver. 3 RFC1813 , NFS ver. 4 RFC3530 , NFS ver. 4.1 RFC5661 .

0/procnettcp.py

These stats are all from /proc/net/tcp{,6}. (Note if IPv6 is enabled, some IPv4 connections seem to get put into /proc/net/tcp6). Collector sleeps 60 seconds in between intervals. Due in part to a kernel performance issue in older kernels and in part due to systems with many TCP connections, this collector can take sometimes 5 minutes or more to run one interval, so the frequency of datapoints can be highly variable depending on the system.

• proc.net.tcp

  Number of TCP connections

For each run of the collector, we classify each connection and generate subtotals. TSD will automatically total these up when displaying the graph, but you can drill down for each possible total or a particular one. Each connection is broken down with a tag for user=username (with a fixed list of users we care about or put under "other" if not in the list). It is also broken down into state with state=, (established, time_wait, etc). It is also broken down into services with <code>service=</code> (http, mysql, memcache, etc) Note that once a connection is closed, Linux seems to forget who opened/handled the connection. For connections in time_wait, for example, they will always show user=root. This collector does generate a large amount of datapoints, as the number of points is (S*(U+1)*V), where S=number of TCP states, U=Number of users you track, and V=number of services (collections of ports). The deduper does dedup this down very well, as only 3 of the 10 TCP states are generally ever seen. On a typical server this can dedup down to under 10 values per interval.

0/procstats.py

Miscellaneous stats from /proc.

• proc.stat.cpu

  (rate) CPU counters (jiffies), tagged by cpu type (type=user, nice, system, idle, iowait, irq, softirq, etc). As a rate they should aggregate up to approximately 100*numcpu per host. Best viewed as type=* or maybe type={user|nice|system|iowait|irq}

• proc.stat.intr

  (rate) Number of interrupts

• proc.stat.ctxt

  (rate) Number of context switches

See http://www.linuxhowtos.org/System/procstat.htm

• proc.vmstat.*

  A subset of VM Stats from /proc/vmstat (mix of rate and non-rate). See http://www.linuxinsight.com/proc_vmstat.html .

• proc.meminfo.*

  Memory usage stats from /proc/meminfo. See the Linux kernel documentation

• proc.loadavg.*

  1min, 5min, 15min, runnable, total_threads metrics from /proc/loadavg

• proc.uptime.total

  (rate) Seconds since boot

• proc.uptime.now

  (rate) Seconds since boot that the system has been idle

• proc.kernel.entropy_avail

  Amount of entropy (in bits) available in the input pool (the one that's cryptographically strong and backing /dev/random among other things). Watch this value on your frontend servers that do SSL unwrapping, if it gets too low, your SSL performance will suffer

• sys.numa.zoneallocs

  Number of pages allocated from the preferred node ( type=hit) or not ( type=miss)

• sys.numa.foreign_allocs

  Number of pages this node allocated because the preferred node didn't have a free page to accommodate the request

• sys.numa.allocation

  Number of pages allocated locally ( type=local) or remotely ( type=remote) for processes executing on this node

• sys.numa.interleave

  Number of pages allocated successfully by the interleave strategy

0/smart-stats.py

Stats from SMART disks.

• smart.raw_read_error_rate

  Data related to the rate of hardware read errors that occurred when reading data from a disk surface. The raw value has different structure for different vendors and is often not meaningful as a decimal number. (vendor specific)

• smart.throughput_performance

  Overall throughput performance of a hard disk drive

• smart.spin_up_time

  Average time of spindle spin up (from zero RPM to fully operational [millisecs])

• smart.start_stop_count

  A tally of spindle start/stop cycles

• smart.reallocated_sector_ct

  Count of reallocated sectors

• smart.seek_error_rate

  Rate of seek errors of the magnetic heads. (vendor specific)

• smart.seek_time_performance

  Average performance of seek operations of the magnetic heads

• smart.power_on_hours

  Count of hours in power-on state, shows total count of hours (or minutes, or seconds) in power-on state. (vendor specific)

• smart.spin_retry_count

  Count of retry of spin start attempts

• smart.recalibration_retries

  The count that recalibration was requested (under the condition that the first attempt was unsuccessful)

• smart.power_cycle_count

  The count of full hard disk power on/off cycles

• smart.soft_read_error_rate

  Uncorrected read errors reported to the operating system

• smart.program_fail_count_chip

  Total number of Flash program operation failures since the drive was deployed

• smart.erase_fail_count_chip

  "Pre-Fail" Attribute

• smart.wear_leveling_count

  The maximum number of erase operations performed on a single flash memory block

• smart.used_rsvd_blk_cnt_chip

  The number of a chip’s used reserved blocks

• smart.used_rsvd_blk_cnt_tot

  "Pre-Fail" Attribute (at least HP devices)

• smart.unused_rsvd_blk_cnt_tot

  "Pre-Fail" Attribute (at least Samsung devices)

• smart.program_fail_cnt_total

  Total number of Flash program operation failures since the drive was deployed

• smart.erase_fail_count_total

  "Pre-Fail" Attribute

• smart.runtime_bad_block

  The total count of all read/program/erase failures

• smart.end_to_end_error

  The count of parity errors which occur in the data path to the media via the drive's cache RAM (at least Hewlett-Packard)

• smart.reported_uncorrect

  The count of errors that could not be recovered using hardware ECC

• smart.command_timeout

  The count of aborted operations due to HDD timeout

• smart.high_fly_writes

  HDD producers implement a Fly Height Monitor that attempts to provide additional protections for write operations by detecting when a recording head is flying outside its normal operating range. If an unsafe fly height condition is encountered, the write process is stopped, and the information is rewritten or reallocated to a safe region of the hard drive. This attribute indicates the count of these errors detected over the lifetime of the drive

• smart.airflow_temperature_celsius

  Airflow temperature

• smart.g_sense_error_rate

  The count of errors resulting from externally induced shock & vibration

• smart.power-off_retract_count

  The count of times the heads are loaded off the media

• smart.load_cycle_count

  Count of load/unload cycles into head landing zone position

• smart.temperature_celsius

  Current internal temperature

• smart.hardware_ecc_recovered

  The count of errors that were recovered using hardware ECC

• smart.reallocated_event_count

  Count of remap operations. The raw value of this attribute shows the total count of attempts to transfer data from reallocated sectors to a spare area

• smart.current_pending_sector

  Count of "unstable" sectors (waiting to be remapped, because of unrecoverable read errors)

• smart.offline_uncorrectable

  The total count of uncorrectable errors when reading/writing a sector

• smart.udma_crc_error_count

  The count of errors in data transfer via the interface cable as determined by ICRC (Interface Cyclic Redundancy Check)

• smart.write_error_rate

  The total count of errors when writing a sector

• smart.media_wearout_indicator

  The normalized value of 100 (when the SSD is new) and declines to a minimum value of 1

• smart.transfer_error_rate

  Count of times the link is reset during a data transfer

• smart.total_lba_writes

  Total count of LBAs written

• smart.total_lba_read

  Total count of LBAs read

Description of metrics can be found at: S.M.A.R.T. article on wikipedia . The best way to understand/find metric is to look at producer's specification.

0/couchbase.py

Stats from couchbase (document-oriented NoSQL database).

All metrics are tagged with name of related bucket(bucket=). A bucket is a logical grouping of physical resources within a cluster of Couchbase Servers. They can be used by multiple client applications across a cluster. Buckets provide a secure mechanism for organizing, managing, and analyzing data storage resources.

Refer to the following documentation for metrics description: Cbstats documentation .

0/elasticsearch.py

Stats from Elastic Search (search and analytics engine).

Refer to the following documentation for metrics description: ElasticSearch cluster APIs .

0/hadoop_datanode_jmx.py

Stats from Hadoop (framework for the distributed processing), DataNode stats.

Following metrics are disabled at the collector by default: revision, hdfsUser, hdfsDate, hdfsUrl, date, hdfsRevision, user, hdfsVersion, url, version, NamenodeAddress, Version, RpcPort, HttpPort, CurrentThreadCpuTime, CurrentThreadUserTime, StorageInfo, VolumeInfo.

Refer to the following documentation for metrics description: HBase metrics .

0/haproxy.py

Stats from Haproxy (TCP/HTTP load balancer).

• haproxy.current_sessions

  Current number of sessions

• haproxy.session_rate

  Number of new sessions per second

All metrics are tagged with server (server=) and cluster (cluster=).

Refer to the following documentation for metrics description: Haproxy configuration # section 9.2.Unix Socket commands

0/hbase_regionserver_jmx.py

Stats from Hadoop (framework for the distributed processing), RegionServer stats.

Following metrics are disabled at the collector by default: revision, hdfsUser, hdfsDate, hdfsUrl, date, hdfsRevision, user, hdfsVersion, url, version, Version, RpcPort, HttpPort,HeapMemoryUsage, NonHeapMemoryUsage.

Refer to the following documentation for metrics description: HBase metrics .

0/mongo.py

Stats from Mongo (document NoSQL database).

Refer to the following documentation for metrics description: Mongo DB server-status .

0/mysql.py

Stats from MySQL (relational database).

Refer to the following documentation for metrics description: InnoDB Innodb monitors , Global Show status , Engine Show engine , Slave Show slave status , Process list Show process list .

0/postgresql.py

Stats from PostgreSQL (relational database).

Refer to the following documentation for metrics description: PostgreSQL monitoring stats .

0/redis-stats.py

Stats from Redis (key-value store).

Refer to the following documentation for metrics description: Redis info comands .

0/riak.py

Stats from Riak (document NoSQL database).

Refer to the following documentation for metrics description: Riak statistics .

0/varnishstat.py

Stats from Varnish (HTTP accelerator).

By default all metrics collected, it can be changed by editing "vstats" array of the collector.

Refer to the following documentation for metrics description: run "varnishstat -l" to have lists the available metrics.

0/zookeeper.py

Stats from Zookeeper (centralized service for distributed synchronization).

Refer to the following documentation for metrics description: Zookeeper admin commands .