You already know how to write Bash, and you already know how to write it well; what is left is putting it all together. This module teaches no new material: it builds. Each lesson takes a real problem at Veloz Envíos and carries it from the statement to a finished tool, explaining at every step why each decision is made and which lesson the technique comes from. We start with the most contained of the five projects, system-info.sh, which is not trivial for all that: it is where you learn the separation between collecting and formatting, the design decision that will reappear in the four projects that follow.

1. The problem: three needs, one single script
2. Requirements written as a checkable list
3. Design: collecting and formatting are two different things
4. Version 1: the smallest thing that works
5. The reliable data sources
6. Version 2: one function per area returning key=value pairs
7. The three formatters
8. Thresholds and colors
9. The interface: options and help
10. Robustness: what to do when the data is not there
11. Putting it to work: inventorying the fleet

At Veloz Envíos, the basic information about a server is needed in three very different situations:

The temptation is to write three scripts, or one with a giant if and three copies of every query. Both age badly: the day you add "load average" you have to touch it in three places and one gets forgotten. The solution is the one you already used without naming it in 04-02 when returning values through stdout: collection knows nothing about the output format.

Before writing code, the requirements, in the form of a list you can tick off:

• [ ] Collects identification (host, distribution, kernel, uptime), hardware (CPU, RAM), disk, memory and load, network and service status.
• [ ] Three output formats: text, tsv, json; and you can request a single section (--section disk).
• [ ] Does not need root for the essentials and does not fail if something is unavailable.
• [ ] Marks out-of-threshold values in the text output, with color only if the output is a terminal and NO_COLOR is not defined.
• [ ] Passes shellcheck -x, finishes in under a second and runs over SSH on all three servers without changes.

This list is the contract. When you doubt whether a function should exist, the answer is here; and when the script is finished, you go through it ticking boxes.

The script has two halves that communicate through a very simple internal format: key=value lines.

The collection functions write to stdout (04-02) and do not print a single header. The formatters read that stream and decide how it looks. Adding a new datum is adding a line inside a function; adding a new format is adding a function that touches no system query at all.

We start with the smallest thing that solves case 1 in the table. No options, no formats.

Twenty seconds of work and it is already useful. This version matters for two reasons. First: it fixes the internal format (key=value) from the very first line, and everything else will grow on top of it. Second: it is runnable and verifiable now, not when it is "finished". Building incrementally means that at no point is there a broken half-written script.

In 06-03 we saw the rule: read files, not output meant for humans. Here it applies to every datum.

LC_ALL=C at the start of the script (06-03) guarantees that decimals use a dot and that error messages do not change with the server's language.

Each function is short, prints no headers and never aborts the script if its source is missing.

Four details that come from earlier lessons. The . /etc/os-release is the 05-06 technique applied to a data file: instead of trimming it with cut, it is loaded and its variables become available. veloz_percentage comes from lib/common.sh and avoids repeating integer arithmetic (04-06). The awk in collect_disk does in one pass what a while read loop would take twenty lines to do (06-01), and the gsub strips the % so the value is numeric and comparable. And the || echo unknown on systemctl is the answer to the requirement of not failing inside a container without systemd: better an honest value than death by set -e.

They receive the key=value stream on standard input. None of them queries anything from the system.

format_text uses printf with the fixed width %-22s (04-04) so the keys line up without column. format_tsv accumulates into an array and takes advantage of the fact that "${row[*]}" joins the elements with the first character of IFS (03-06): assigning IFS=$'\t' as local makes the separator a tab only inside the function. And format_json builds the arguments for jq -n --arg in an array (06-05) so that escaping quotes, accents and backslashes is done by jq and not by us; $ARGS.named is the object with all the --arg values received. Writing that JSON by hand with printf would be the fastest way to generate invalid JSON the day a hostname contains an odd dash.

Thresholds live in a single table, not scattered around the code:

The comparison is delegated to awk because the values may be decimals and [[ ]] only compares integers (04-06). The +0 forces a number, so that a non-numeric value such as unknown evaluates as 0 and is never painted red. The decision about color, on the other hand, is taken only once, at startup (03-05):

Three conditions and all three matter. -t 1 detects that stdout is a terminal: if the script is redirected to a file or piped into grep, the escape codes would pollute the result. NO_COLOR is a convention respected by many tools and costs one line. And color is always disabled in TSV and JSON, because there the output is read by a machine.

The while+case loop is chosen over getopts (03-05) for one concrete reason: we want readable long options in the runbook, and getopts only handles short ones. The ${2:?...} cuts off at the root the classic error of --format with no value. The explicit -- allows for positional arguments one day. And validating $FORMAT with a regular expression (05-04) instead of with a case in the dispatcher means the error is detected at startup, not halfway through the run.

The main dispatcher walks the requested sections and funnels everything into a single formatter:

The brace that groups the loop (05-05) lets all the loop's output enter the formatter through a single pipe. And declare -F checks that the function exists before invoking it: the section becomes a function name, but only if that function is defined, which is the allowlist of 08-03 applied without writing the list twice.

set -euo pipefail kills the script on any failure, and that is correct for programming errors but disastrous for a missing datum. The project rule: a missing datum is n/a, not a death.

The last case is the most treacherous: data that never arrives is worse than data that fails, because a hung script generates no alert. timeout turns the block into a visible error.

With the TSV format, the inventory of the three servers is one line reusing fleet.sh (07-06):

The script is sent over standard input instead of being installed on each server: that way the inventory always reflects the latest version and there is nothing to keep in sync. And to attach context to an alert, system-info.sh --format json --section memory_load produces exactly the object the 07-04 webhook expects.

• Mixing collection and format. If a collection function prints printf 'Memory: %s%%', the JSON becomes useless. The acid test: no collect_* function should contain alignment spaces, colons or colors.
• Building JSON by hand. printf '{"host":"%s"}' works until a value contains a quote or a backslash. Always jq -n --arg.
• Comparing decimals with [[ ]]. [[ 1.5 -gt 1 ]] does not give a syntax error, it gives a runtime error, and with set -e that kills the script. Decimals go through awk or bc.
• Forgetting -P in df or LC_ALL=C for decimals. Without -P, a device with a long name splits the line in two and the awk reads the wrong column.
• Coloring without checking -t 1. The day somebody runs system-info.sh > status.txt, the file fills up with \033[31m.
• Tip: time the script with time (08-02). If it takes more than a second, it is almost certainly a for launching one process per datum; group it into a single awk.

1. Packages section. Add collect_packages, reporting packages_installed and packages_upgradable (use apt list --upgradable on Ubuntu), and needs_reboot according to whether /var/run/reboot-required exists. It must degrade to n/a on a system without apt.
2. Compare two runs. Write the --compare FILE subcommand: save one run in key=value form and, when invoked, show only the keys whose value has changed with respect to the file, in the format key: before -> now.
3. Temperature section. Add collect_temperature reading /sys/class/thermal/thermal_zone*/temp (thousandths of a degree) with globbing (02-05) and $(<file) instead of cat (08-02), and mark in red anything above 75 °C by adding its key to the THRESHOLD table, without touching color_for.

1. The key is isolating each query with its own safeguard:

The || true after grep -c is essential: grep returns 1 when it finds nothing, and with set -e that would be the end of the script even though "zero upgradable" is the best possible news.

2. We take advantage of the internal format already being key=value, so an associative array is enough (04-03):

That it is just one more formatter is the payoff of having separated the two halves: comparing required touching not a single system query.

3. The loop walks /sys/class/thermal/thermal_zone*/temp with [[ -r $z ]] || continue to skip unreadable zones, and emits printf 'temp_%s=%s\n' "$n" "$(( $(<"$z") / 1000 ))". Adding [temp_0]=75 to THRESHOLD is enough for the coloring to work on its own.

system-info.sh is finished and meets the eight boxes of the contract in section 2. More important than the script is the design decision that structures it: separating collection from formatting, with a minimal internal format (key=value) as the boundary between the two. Thanks to it, three output formats coexist without a single duplicated query, adding a datum is one line, adding a format is one function, and comparing two runs —exercise 2— was solved without touching collection. The rest of the project has been applying what you learned: reliable sources in /proc and files instead of human-readable output (06-03), printf with widths (04-04), jq -n --arg (06-05), an allowlist via declare -F (08-03), timeout against hangs (05-02) and an interface with long options and early validation (03-05). And an operating rule that holds for the whole module: a missing datum is n/a, not an exception.

In 09-02 the input material stops being a handful of /proc files with one line each and becomes a million lines of access.log and app.log. We will build analyze-logs.sh: a single pass with awk, transparent reading of rotated and compressed files, filters by date and level, aggregations, a histogram drawn with printf, anomaly detection and a report in text and JSON —the most demanding project in the course when it comes to text processing.