4550015ec · cryptotaxi247/netdata-1

@@ -1633,10 +1633,26 @@ netdataDashboard.context = {

1633 info: 'Amount of data transferred to and from disk.'

1634 },

1635

1636 + 'disk_ext.io': {

1637 + info: 'Amount of discarded data that are no longer in use by a mounted file system.'

1638 + },

1639 +

1640 'disk.ops': {

1641 info: 'Completed disk I/O operations. Keep in mind the number of operations requested might be higher, since the system is able to merge adjacent to each other (see merged operations chart).'

1642 },

1643

1644 + 'disk_ext.ops': {

1645 + info: 'Number (after merges) of completed discard/flush requests.'+

1646 + 'Discard commands inform disks which blocks of data are no longer considered to be in use and therefore can be erased internally. '+

1647 + 'They are useful for solid-state drivers (SSDs) and thinly-provisioned storage. '+

1648 + 'Discarding/trimming enables the SSD to handle garbage collection more efficiently, '+

1649 + 'which would otherwise slow future write operations to the involved blocks down.'+

1650 + 'Flush operations transfer all modified in-core data (i.e., modified buffer cache pages) to the disk device '+

1651 + 'so that all changed information can be retrieved even if the system crashes or is rebooted. '+

1652 + 'Flush requests are executed by disks. Flush requests are not tracked for partitions. '+

1653 + 'Before being merged, flush operations are counted as writes.'

1654 + },

1655 +

1656 'disk.qops': {

1657 info: 'I/O operations currently in progress. This metric is a snapshot - it is not an average over the last interval.'

1658 },

@@ -1646,14 +1662,16 @@ netdataDashboard.context = {

1662 info: 'The sum of the duration of all completed I/O operations. This number can exceed the interval if the disk is able to execute I/O operations in parallel.'

1663 },

1664 'disk_ext.iotime': {

1649 - height: 0.5

1665 + height: 0.5,

1666 + info: 'The sum of the duration of all completed discard/flush operations. This number can exceed the interval if the disk is able to execute discard/flush operations in parallel.'

1667 },

1668 'disk.mops': {

1669 height: 0.5,

1670 info: 'The number of merged disk operations. The system is able to merge adjacent I/O operations, for example two 4KB reads can become one 8KB read before given to disk.'

1671 },

1672 'disk_ext.mops': {

1656 - height: 0.5

1673 + height: 0.5,

1674 + info: 'The number of merged discard disk operations. Discard operations which are adjacent to each other may be merged for efficiency.'

1675 },

1676 'disk.svctm': {

1677 height: 0.5,

@@ -1668,7 +1686,8 @@ netdataDashboard.context = {

1686 info: 'The average I/O operation size.'

1687 },

1688 'disk_ext.avgsz': {

1671 - height: 0.5

1689 + height: 0.5,

1690 + info: 'The average discard operation size.'

1691 },

1692 'disk.await': {

1693 height: 0.5,

@@ -1676,7 +1695,7 @@ netdataDashboard.context = {

1695 },

1696 'disk_ext.await': {

1697 height: 0.5,

1679 - info: 'The average time for extended I/O requests issued to the device to be served. This includes the time spent by the requests in queue and the time spent servicing them.'

1698 + info: 'The average time for discard/flush requests issued to the device to be served. This includes the time spent by the requests in queue and the time spent servicing them.'

1699 },

1700

1701 'disk.space': {

@@ -1686,6 +1705,50 @@ netdataDashboard.context = {

1705 info: 'inodes (or index nodes) are filesystem objects (e.g. files and directories). On many types of file system implementations, the maximum number of inodes is fixed at filesystem creation, limiting the maximum number of files the filesystem can hold. It is possible for a device to run out of inodes. When this happens, new files cannot be created on the device, even though there may be free space available.'

1706 },

1707

1708 + 'disk.bcache_hit_ratio': {

1709 + info: 'Bcache (block cache) is a cache in the block layer of Linux kernel, '+

1710 + 'which is used for accessing secondary storage devices. '+

1711 + 'It allows one or more fast storage devices, such as flash-based solid-state drives (SSDs), '+

1712 + 'to act as a cache for one or more slower storage devices, such as hard disk drives (HDDs).'+

1713 + 'Percentage of data requests that were fulfilled right from the block cache. '+

1714 + 'Hits and misses are counted per individual IO as bcache sees them. '+

1715 + 'A partial hit is counted as a miss.'

1716 + },

1717 + 'disk.bcache_rates': {

1718 + info: 'Throttling rates. '+

1719 + 'To avoid congestions bcache tracks latency to the cache device, and gradually throttles traffic if the latency exceeds a threshold. ' +

1720 + 'If the writeback percentage is nonzero, bcache tries to keep around this percentage of the cache dirty by '+

1721 + 'throttling background writeback and using a PD controller to smoothly adjust the rate.'

1722 + },

1723 + 'disk.bcache_size': {

1724 + info: 'Amount of dirty data for this backing device in the cache.'

1725 + },

1726 + 'disk.bcache_usage': {

1727 + info: 'Percentage of cache device which does not contain dirty data, and could potentially be used for writeback.'

1728 + },

1729 + 'disk.bcache_cache_read_races': {

1730 + info: 'Read races happen when a bucket was reused and invalidated while data was being read from the cache. '+

1731 + 'When this occurs the data is reread from the backing device. '+

1732 + 'IO errors are decayed by the half life. '+

1733 + 'If the decaying count reaches the limit, dirty data is written out and the cache is disabled.'

1734 + },

1735 + 'disk.bcache': {

1736 + info: 'Hits and misses are counted per individual IO as bcache sees them; a partial hit is counted as a miss. '+

1737 + 'Collisions happen when data was going to be inserted into the cache from a cache miss, '+

1738 + 'but raced with a write and data was already present. '+

1739 + 'Cache miss reads are rounded up to the readahead size, but without overlapping existing cache entries.'

1740 + },

1741 + 'disk.bcache_bypass': {

1742 + info: 'Hits and misses for IO that is intended to skip the cache.'

1743 + },

1744 + 'disk.bcache_cache_alloc': {

1745 + info: 'Working set size. '+

1746 + 'Unused is the percentage of the cache that does not contain any data. '+

1747 + 'Dirty is the data that is modified in the cache but not yet written to the permanent storage. '+

1748 + 'Clean data matches the data stored on the permanent storage. '+

1749 + 'Metadata is bcache\'s metadata overhead. '

1750 + },

1751 +

1752 // ------------------------------------------------------------------------

1753 // ZFS pools

1754 'zfspool.state': {

add diskstats charts info (#11528)