zpool iostat --color

[trentbuck]

zpool iostat --color (easily tell K from M from G)

Right now, when doing zpool iostat -w or zpool iostat -r, it's easy to tell 0 from non-0 at a glance, by the "shape" of the cells.
However it's not easy to tell the order of magnitude of the non-zero cells.

On color terminals, a straightforward option would be to make (say) 0 grey; 1-999 white; K green; M yellow; G red; T bold/bright red.

On 8bpp and 24bpp terminals (TERM=xterm-color &c), you could do a more complicated heat map. I don't really need that level of fanciness.

As a quick hack, I am currently resorting to zpool iostat -r | grep -E --color -e ^ -e [0-9.]+G, i.e. "spot" color.

[rincebrain]

I've got a few prettifiers that I've found useful, though I don't think I've tried zpool iostat yet.

What I found useful for my purposes was a color gradient from 1 to 1024 (since it bumps the unit at that point), and then a color for K/M/G/T/E/P...

It sounds like something much coarser for just different colors per unit would suffice for your desires. (I wonder if it'd be nice to tint the background color of the row based on proportion of IOs as well.)

Maybe I'll take a pass at it if I need something to do in the next few days.

[behlendorf]

The zpool status output was optionally colorized in 9fb2771. You can enable it by setting the ZFS_COLOR environment variable. If someone feels like taking a swing at this you can use the existing printf_color() interface.

[nabijaczleweli]

If we really want to go all out, htop leads the way in colouring numbers:

[tonyhutter]

It was always my hope with 9fb2771 to get around to colorizing all the other zpool commands. If someone wants to take it on, feel free to put me down as a reviewer. As @behlendorf mentioned, we already have the functions for printing things in color (printf_color(), color_start(), color_end()) so all you'd have to do is just update the printfs on the commands.

[rincebrain]

If we really want to go all out, htop leads the way in colouring numbers:

I mean, if you're taking number of colors as the metric...

Screenshots aside, I will probably take a crack at this.

[trentbuck]

I would still like this just built-into zpool C, but I did a post-processing script in a half-hour.

#!/usr/bin/python3
import re
import sys

import click  # https://click.palletsprojects.com/en/8.1.x/utils/#ansi-colors

__doc__ = """ colorize numbers on stdin by their size
for line in sys.stdin:
    new_string, previous_end, any_matches = '', 0, False
    for m in re.finditer(r'\b\d+(?:\.\d+)?[KMGTP]i?B?\b', line):
        any_matches = True
        new_string += line[previous_end:m.start(0)]
        new_string += click.style(
            text=m.group(0),
            fg=('bright_red' if 'P' in m.group(0) else
                'red'        if 'T' in m.group(0) else
                'yellow'     if 'G' in m.group(0) else
                'green'      if 'M' in m.group(0) else
                'white'      if 'K' in m.group(0) else
                'black'))
        previous_end = m.end(0)
    if any_matches:
        new_string += line[previous_end:]
    print(new_string if any_matches else line, end='')

[ethan-coe-renner]

I'm interested in taking this on and using the interface from 9fb2771 like @behlendorf and @tonyhutter suggested. That interface should make it straightforward to color based on the order of magnitude of the cell.

@rincebrain I wanted to check if you made any progress, or still want to work on this?

[IvanVolosyuk]

@trentbuck I was using your script above as it makes it much easier to spot large datasets, snapshots, etc. But it was not enough for me, so I made a true color version which is more nuanced. I actually use more with 'zfs list -o space' to spot large dataset :)

#!/usr/bin/python3
import re
import sys
import math

# Can be specified as argument to scale colors differently.
maxval = 3e12

if len(sys.argv) > 1:
  maxval = float(sys.argv[1])

# Minimal brights of other color component
contrast = 10
max_brightness = 255 * 255 + contrast * contrast
scale = (255 - contrast) / math.log10(maxval)

def colorize(numtxt0):
    numtxt = numtxt0
    mul = 1
    base = 1000
    if numtxt.endswith("B"):
        numtxt = numtxt[0:-1]
    if numtxt.endswith("i"):
        numtxt = numtxt[0:-1]
        base = 1024

    if numtxt.endswith("K"):
        mul = base
    elif numtxt.endswith("M"):
        mul = base * base
    elif numtxt.endswith("G"):
        mul = base * base * base
    elif numtxt.endswith("T"):
        mul = base * base * base * base
    elif numtxt.endswith("P"):
        mul = base * base * base * base * base

    if mul != 1:
        numtxt = numtxt[0:-1]

    num = float(numtxt) * mul

    if num == 0:
        return numtxt0

    redness = min(255, int(math.log10(num) * scale + contrast))
    complement = min(255, int(math.sqrt(max_brightness - redness * redness)))

    return "\033[38;2;%d;%d;0m%s\033[m" % (redness, complement, numtxt0)


for line in sys.stdin:
    new_string, previous_end, any_matches = '', 0, False
    for m in re.finditer(r'\b\d+(?:\.\d+)?[KMGTP]?i?B?\b', line):
        any_matches = True
        new_string += line[previous_end:m.start(0)]
        new_string += colorize(m.group(0))
        previous_end = m.end(0)
    if any_matches:
        new_string += line[previous_end:]
    print(new_string if any_matches else line, end='')

[trentbuck]

I was using your script above as it makes it much easier to spot large datasets, snapshots, etc.

For what it's worth, I have been using ZFS_COLOR=1 for years now (instead of my proof-of-concept script).