Home › Topics › Monitoring on a Budget: Free and Low-Cost Stacks › Free Stacks That Punch Above Their Weight

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:


ComponentJobWhat you configure
Monitoring core (one of the open-source families)Up/down, SNMP graphs, thresholds, alerts, basic dashboardHost list, SNMP credentials, a handful of thresholds, one notification method
Latency grapherLatency and loss history per site and providerA target list; almost nothing else
Syslog collectorDevice and server logs in one searchable placeA 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

ComponentPlacementEffort
Monitoring core with built-in dashboardOne small VMA day to build; an hour or two a month to keep
Latency grapherSame VMAn hour to build; minutes a month
Syslog to the distribution's daemonSame VMAn 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

ComponentPlacementEffort
Monitoring coreOne VM at the main siteTwo or three days to build and tune; half a day a month
Latency grapherSame VM, targets at every siteHalf a day; minutes a month
Syslog collector with a nightly digest scriptSame VM, larger diskA day including the script; an hour a month
Flow collector for the firewall and site routersSame VM or a second one if disk is tightA day or two; an hour a month plus disk housekeeping
Dashboard layerSame VMA 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

ComponentPlacementEffort
Monitoring core with remote pollersCentral VM plus a poller per siteA week to build well; a day a month across the team
Latency grapherCentral, plus probes at sitesA day; minutes a month
Syslog collector with searchIts own VM; retention policy in writingTwo or three days; half a day a month
Flow collectorIts own VM; sampled flows from edge devicesTwo days; half a day a month
Dashboard layer with per-site viewsCentralTwo days; ongoing
Configuration in version control; documented restoreRepository plus backupsA 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