Free Stacks That Punch Above Their Weight
There is a moment in every small IT shop where the utility belt stops being enough. You have ping and snmpwalk and a folder of scripts, and you still found out about the dead switch from the receptionist. I remember mine. The switch had been down for forty minutes, and the reach-check script had written a line about it that nobody had read. What you want is something that watches all the time, remembers what it saw, and tells you first. What you have is a budget line that reads zero. The good news is that the open-source world has produced excellent monitoring components. A handful of them, chosen and assembled with care, make a stack that genuinely punches above its weight.
The trick is the word coherent. A pile of free tools is not a stack; it is a pile. A stack is a set of pieces where each job has one home, and the homes know about each other. And you know which screen to open for which question.
This guide shows how to think about the jobs a stack has to do and which open-source pieces do them. It shows how to assemble a minimum viable stack for a small organization on a single server. And it shows what the tradeoffs are when nobody sends you an invoice. It deliberately does not crown a winner among the open-source families, because the right one depends on your network, your skills, and your patience. By the end you will be able to sketch a stack for your own size of organization. You will know what running it will cost you in the currency that matters: hours.
In this guide
- The five jobs a monitoring stack has to do
- The core: up/down checks plus SNMP graphing
- The latency grapher
- The syslog collector
- The flow collector, where devices can export
- The dashboard
- The minimum viable stack: three components, one server
- The tradeoffs nobody invoices you for
- Reference architectures: tiny, small, growing
- The rule of one alert path
- When the free stack is the right permanent answer
The five jobs a monitoring stack has to do
Strip away vendor vocabulary and every monitoring setup, free or paid, does five jobs. It tells you whether things are up or down. It graphs how busy and healthy they are over time, mostly by polling devices over SNMP (Simple Network Management Protocol, the standard way devices report on themselves). It watches latency — the round-trip time across your paths — so that "slow" becomes measurable. It collects logs that devices send, so that when something breaks you can read what the device said at the moment it broke. And where devices support it, it collects flows: summaries of who talked to whom. That lets "the link is full" become "the link is full of backup traffic from the accounting server."
A sixth job sits on top. It is a dashboard that shows all of that on one screen. It is for you at seven in the morning and for the manager who asks how things are going. Coherence, again, means each of the six jobs has exactly one home. An incoherent stack does the same six jobs in nine places, two of which are tabs on a laptop that has gone home for the night.
The core: up/down checks plus SNMP graphing
Start with the piece that does the two biggest jobs at once. Every major open-source monitoring family provides a core that pings your devices on a schedule. It polls them over SNMP for interface status and traffic counters, stores the results, and draws graphs. It raises alerts when a threshold is crossed or a host stops answering. This one component replaces most of your scripts, and it is the foundation everything else attaches to.
The families differ in philosophy more than in capability. Some are built around a human-written configuration and a check-plugin model. Some are built around auto-discovery of network devices with graphs out of the box. Others are built around a time-series database (a store built for numbers stamped with the time they were taken) with a separate graphing layer. The differences matter for how much you type and how the stack grows. And they are laid out without favoritism in the Guided Tour of the Open-Source Monitoring Stacks. For this guide, what matters is the shape of the core, which is the same everywhere:
- A list of hosts, added by hand or discovered, each with a way to reach it (ping) and a way to ask it questions (SNMP credentials).
- A poller that runs on a schedule — usually every one to five minutes — and asks each host for a fixed set of values.
- A store for the answers, so that today's traffic can be graphed against last month's.
- Thresholds and alerts, so that a value crossing a line, or a host going quiet, results in a notification rather than a graph nobody looks at.
If you build nothing else, build this. Take a core with your switches, firewalls, servers, and key printers in it, polling interfaces and pinging hosts. That moves you from "found out from the receptionist" to "found out from the email" — most of the value of monitoring in one step.
The latency grapher
The core's ping tells you up or down, and usually records a round-trip time. But it does not specialize in the texture of latency. That includes jitter (how much the round-trip time varies from one probe to the next). It also includes afternoon spikes and loss that comes and goes on the branch office link. A dedicated latency grapher — SmokePing is the well-known open-source one — sends many probes per interval and draws the spread. So a link's personality is visible at a glance. The grapher is the component that turns "the VPN felt slow yesterday" into a graph you can point at. And its setup is covered in the guide on SmokePing latency graphing.
It is small, undemanding, and happy to share a server with the core. Point it at each site's gateway, your provider's first hop, and a couple of external references, and leave it alone. Some cores approximate this job with their own ping graphs; if yours does well enough, one fewer component is a legitimate choice.
The syslog collector
Syslog is the standard by which network devices and servers send short log messages to a central place. Examples are "interface down," "login failed," "spanning-tree topology change," and "fan failed." Without a collector those messages sit on the device in a small buffer and are lost on reboot, which is precisely when you wanted them. With a collector they land in files or a database on your monitoring server, searchable and timestamped.
Nearly every Linux system ships with a capable syslog daemon (a background service that runs without a user logged in). It can receive from the network and sort messages into per-device files. Several of the monitoring families can also ingest syslog directly and display it next to the device's graphs. Either way, the device side is one line: send logs to the collector's address. The collector side is a listener and a rule for where to put things. Here is the shape of it, in the syntax of the daemon most distributions ship:
# Listen for syslog from the network on UDP 514
module(load="imudp")
input(type="imudp" port="514")
# Sort incoming messages into one file per sending device
template(name="PerHost" type="string" string="/var/log/net/%HOSTNAME%.log")
if ($fromhost-ip startswith "10.") then { action(type="omfile" dynaFile="PerHost") }
Once logs are flowing, the habit that pays off is a nightly digest. A small script counts messages per device and lists anything containing words like fail, down, or error. Ten lines of reading each morning catches a surprising number of problems that never trip a threshold.
The flow collector, where devices can export
Interface graphs tell you a link is busy. Flow records tell you why. Routers, firewalls, and many switches can export summaries of each conversation they forward — source, destination, ports, byte counts. They use standards with names like NetFlow, sFlow, and IPFIX. A flow collector receives those records and stores them. It answers questions like "what are the top talkers on the branch link right now?" and "what was flooding the uplink at three this morning?"
The "where devices export" qualifier is important. Not every device can send flows, some send only sampled flows, and on cheaper gear enabling export can load the CPU. Check the device first. If your firewall or core router supports it, a flow collector is the most illuminating addition to a small stack. It converts capacity arguments into evidence. Several open-source cores include or integrate a flow module; standalone open-source collectors also exist. The deciding factor is usually which one shows flows next to the interface graph, so you are not cross-referencing two screens by hand.
The dashboard
A stack that only sends emails is a stack nobody looks at between emails. The dashboard is a single screen, on a wall or a second monitor. It shows host status, the busiest interfaces, latency to each site, and the last few alerts. Most cores include one. If yours is thin, a separate open-source graphing layer can read from most stores and draw very good panels. That costs one more component to maintain.
Keep it simple. One screen, the twenty things that matter, red for down and green for up. A dashboard with sixty panels and a scroll bar is a report, not a dashboard, and it stops being glanced at within a week.
The minimum viable stack: three components, one server
Take a small organization — one or two sites, a few dozen network devices, a rack of servers. Its minimum viable stack is three components on one modest server or virtual machine:
| Component | Job | What you configure |
|---|---|---|
| Monitoring core (one of the open-source families) | Up/down, SNMP graphs, thresholds, alerts, basic dashboard | Host list, SNMP credentials, a handful of thresholds, one notification method |
| Latency grapher | Latency and loss history per site and provider | A target list; almost nothing else |
| Syslog collector | Device and server logs in one searchable place | A listener, a per-device file rule, and one line on each device |
That is the whole thing. Flows and a richer dashboard come later, when the core is stable and you have a question they answer. The order of work on day one:
- Build the server. A Linux VM with generous disk (graphs and logs grow), a static address, and a backup job from the start.
- Install the core and add ten devices that matter most: the firewall, the core switch, the servers users touch, the site links.
- Set one alert path (see the rule below) and test it by unplugging something harmless.
- Add the latency grapher pointed at each site and the provider.
- Turn on syslog on the ten devices, pointed at the collector.
- Write down what you installed, where the configuration lives, and how to restore it. Today, while you remember.
Tip: resist adding every device on the first day. Ten well-configured hosts with a tested alert path beat two hundred hosts and a flood of untuned notifications. Add the rest in batches once you trust what the first ten tell you.
The tradeoffs nobody invoices you for
Free software has a price; it is simply paid in a different currency. Being honest about it is what separates a stack that survives from one that quietly rots.
Assembly time
A packaged product installs and discovers your network in an afternoon. A free stack asks you to install a database, a web server, the core, its dependencies, the grapher, and the collector. Then it asks you to make them all start on boot and survive an update. Expect days rather than hours for the first build, plus a learning curve per component. It is not wasted time — you will understand your monitoring in a way a wizard never teaches — but it is time.
Upkeep
Each component has its own release cycle, its own upgrade notes, and its own way of breaking on a distribution update. Three components means three things to patch and three things that may disagree about a library version. Set a recurring upgrade window and treat it as real work, because it is.
Integration seams
The pieces were written by different people with different assumptions. The core knows a switch as one thing. The syslog collector knows it by whatever hostname it announced; the latency grapher knows it by an address. Making a click in one tool land on the right page in another is glue you write and maintain. Every seam is a place where "look at the graph and the log together" becomes two browser tabs.
One expert
Free stacks tend to be built by one enthusiastic person and understood by one person. That is fine until that person is on holiday during an outage, or leaves. The cost is invisible until the day it is enormous. The guide on the real cost of free lays out how to account for it honestly before it accounts for you.
Meridian Parts ran a free stack for a long time on the strength of the licence fee it saved. The saving was real; it appeared on a slide every budget round. What did not appear on the slide was the admin who built it. He patched the three components on Sunday evenings because that was the only upgrade window nobody had to approve. When he left, the handover note for the stack read "ask me". The core ran unpatched from then on, alerting faithfully into a mailbox that had been closed along with his account. The licence fee it saved was real. So were the evenings.
Reference architectures: tiny, small, growing
Three sketches, sized by organization rather than technology. Effort figures are the honest sort: time to build, then time to keep it healthy.
Tiny: one site, a handful of devices, one admin
| Component | Placement | Effort |
|---|---|---|
| Monitoring core with built-in dashboard | One small VM | A day to build; an hour or two a month to keep |
| Latency grapher | Same VM | An hour to build; minutes a month |
| Syslog to the distribution's daemon | Same VM | An hour; check disk usage quarterly |
Here even the three-component minimum can shrink: if the core's ping graphs are good enough, skip the separate grapher. The dashboard is the core's own status page on a spare screen.
Small: two or three sites, dozens of devices, a two-person team
| Component | Placement | Effort |
|---|---|---|
| Monitoring core | One VM at the main site | Two or three days to build and tune; half a day a month |
| Latency grapher | Same VM, targets at every site | Half a day; minutes a month |
| Syslog collector with a nightly digest script | Same VM, larger disk | A day including the script; an hour a month |
| Flow collector for the firewall and site routers | Same VM or a second one if disk is tight | A day or two; an hour a month plus disk housekeeping |
| Dashboard layer | Same VM | A day to build panels worth looking at; occasional tweaks |
At this size a remote poller at the second site is worth considering. That way, a WAN (wide area network) outage is reported as "the link is down" rather than "everything at the branch is down." Most families support a remote poller or a satellite instance.
Growing: several sites, hundreds of devices, a small team with turnover
| Component | Placement | Effort |
|---|---|---|
| Monitoring core with remote pollers | Central VM plus a poller per site | A week to build well; a day a month across the team |
| Latency grapher | Central, plus probes at sites | A day; minutes a month |
| Syslog collector with search | Its own VM; retention policy in writing | Two or three days; half a day a month |
| Flow collector | Its own VM; sampled flows from edge devices | Two days; half a day a month |
| Dashboard layer with per-site views | Central | Two days; ongoing |
| Configuration in version control; documented restore | Repository plus backups | A day to set up; discipline thereafter |
This is where the free stack stops being a side project and becomes a system with owners, change control, and a roster. It can absolutely be run this way. The honest observation is that at this size the hours it consumes each month start to look like a fraction of a salary. And the guide on where spending actually helps becomes worth a careful read.
The rule of one alert path
A free stack has an odd temptation: because each component can alert, each component does. The core emails. The grapher emails. The syslog digest emails. The flow collector has a threshold feature and, naturally, it emails. Within a month you have four sources of notifications with four formats and four sets of thresholds. You have no single place to see what is currently wrong. Duplicate and contradictory alerts are how a monitoring system loses the trust of the people it is supposed to help.
The rule: one alert path. Exactly one component sends notifications to humans, and it is the core, because the core knows which hosts depend on which. Everything else feeds information toward the core or stays silent. If the syslog collector spots a critical message, it raises it through the core's passive-check or trap mechanism. This is a way for the core to accept a result it did not poll for. That keeps dependency suppression, maintenance windows, and acknowledgement in one place. If the flow collector sees a top-talker anomaly, it shows it on the dashboard, not in your inbox.
In practice this means three settings. In the core: one notification method, tested, with a maintenance-window feature you actually use. In every other component: notifications off, or pointed at the core. And in your own head: when you feel the urge to add a second email route "just for this one thing," add it to the core instead. One path, one format, one screen showing what is open right now.
When the free stack is the right permanent answer
It is fashionable to describe free stacks as a stepping stone. Sometimes they are. Often they are simply the right answer, and it is worth saying when.
The free stack is the right permanent answer when the environment is stable and modest. That means a site or two, devices that rarely change, and no plan to double. It is right when the team has the skill and enjoys the craft. Take an admin who likes the command line, keeps the configuration in version control, and treats upgrade day as a small pleasure rather than a dread. That admin will run a free stack better than most packaged products are run. It is right when the hours are genuinely available. A half day a month of care must be affordable and must not otherwise go to something more valuable. And it is right when the organization's needs match what the pieces do well: up/down, SNMP graphs, logs, and flows. The organization must not need deep application-level checks or a vendor to call.
It stops being the right answer when those conditions flip. That includes when the hours are being stolen from projects or when the one expert is leaving. It includes when leadership wants a support contract behind the critical system or when the stack itself has become a job. Those signals are covered in the guide on the hidden costs of cheap. Until they appear, a coherent three-component stack, built with care and given one alert path, is not a compromise. It is a perfectly good monitoring system that happens to have cost you nothing but attention.
Where to go next
Pick a core from one of the open-source families, build the three-component minimum on one server, and give it ten devices and one alert path this week. Add flows and a dashboard when a real question demands them, not before. Write down what you built while you still remember why. Then keep reading the Monitoring on a Budget: Free and Low-Cost Stacks topic. It covers where a little money helps and what cheap really costs. It offers a staged roadmap from this first stack to one you would trust at three in the morning. Built this way, the next dead switch reaches your inbox before it reaches the receptionist.
Put this into practice with SysPeep Monitor
Some teams build the three-component stack and love it; others discover they would rather spend those build-and-upkeep hours elsewhere. SysPeep Monitor is a commercial alternative for the second group — discovery, SNMP polling, thresholds with dependencies, alerts, and dashboards in one Windows service. It is not free, but the trial is. So you can compare it against your own stack before deciding which currency you would rather pay in.
Download Free TrialLearn About SysPeep