Home › Topics › A Guided Tour of the Open-Source Monitoring Stacks › LibreNMS

LibreNMS: Network-First Auto-Discovery


A new switch went into a wiring closet on Tuesday. On Wednesday someone asked why the third floor was slow. I wanted a traffic graph for the uplink, except nobody had added the switch to monitoring yet. Adding it meant defining forty-eight ports by hand in a tool built for servers. So there was no graph, and "probably fine" became the official finding.


The network-first family exists to make that scene impossible. Give the system a device's address and SNMP credentials and it does the rest. It works out what the device is, finds every port and sensor on it, and starts drawing a graph for each one before your coffee is cold. LibreNMS is the best-known open-source project built on that idea. It carries forward a tradition of SNMP-polled graphing that runs back through Cacti and the round-robin graphing tools of an earlier era.


This tour explains the design: SNMP as the primary language. It covers what discovery does in the first few minutes after you add a device and why every port gets a graph by default. It covers how alert rules sit on top and what syslog and flow ingestion add. It is honest about the limits, covers polling load, and ends with fit and what to check in the current documentation.


In this guide

  • The design: SNMP as the primary language
  • Adding a device: what discovery does in the first few minutes
  • A graph for every port and sensor
  • Alert rules on top
  • Syslog, flows, and other add-ons
  • Strengths and honest limits
  • Operational notes: polling load and distributed pollers
  • Learning curve and where it fits
  • The concepts in one table
  • What to check in the current docs before committing
  • Where to go next

The design: SNMP as the primary language


Every family in this tour can speak SNMP. The network-first family is the one that thinks in it. SNMP — the Simple Network Management Protocol — is the standard way network devices expose their facts. Each fact has a numbered address called an OID, and dictionaries called MIBs give those numbers names. If OIDs and MIBs are new to you, the OIDs and MIBs guide explains the numbered filing cabinet properly. For this tour it is enough that a switch will answer questions like "what are your interfaces?" and "how many bytes has port twelve received?" if you ask in SNMP.


The atom of the design is the device: a thing with an address that speaks SNMP. Everything hangs off devices. Ports belong to devices. Sensors belong to devices. Graphs, alerts, logs, and neighbor relationships all belong to devices. When you open the system, the first thing you see is a list of devices, and the device page is where you spend your day.


In the collector-storage-alerting-UI vocabulary from the family overview, there are several pieces. A discovery process learns what each device has. A poller fetches current values for everything discovery found. A relational database holds the inventory (devices, ports, sensors, and their properties). A set of time-series files holds the polled values for graphing. An alerting engine evaluates rules against the inventory and latest values. A web UI is built around the device list. Optional collectors for syslog and flow records attach their data to the same devices.


The time-series storage is the family's inheritance. The tradition is the round-robin database. This uses a fixed-size file per metric that never grows. As data ages it is averaged down into coarser buckets: every five minutes for the recent past, hourly for last month, daily for years ago. You get high resolution where you need it and a file size you can predict forever, in exchange for losing fine detail from long ago. Nobody has yet asked me for five-minute detail of a Tuesday three years back. Projects in this family can often be pointed at other time-series stores too; check the current documentation for what is supported.


Adding a device: what discovery does in the first few minutes


Follow one device from "added" to "graphed." The general mechanics of discovery — sweeping, interrogating, classifying — are in the how auto-discovery works guide. This is how the network-first family applies them to one device.


  • 1. You add the device. An address or hostname plus SNMP credentials. That is all. You do not tell it what kind of device it is or what to monitor.
  • 2. Identification. The system reads the device's self-description over SNMP — its system description and its vendor object identifier. It matches them against a library of device definitions maintained by the community. The match decides which vendor-specific OIDs to use for the rest of discovery.
  • 3. Discovery modules run. Each module enumerates one category. Categories include interfaces (name, speed, type, status), processors, memory, storage, temperature and fan and power sensors, and optical transceiver readings. They include VLANs, ARP and MAC address tables, routing neighbors, and neighbor devices seen through link-layer discovery protocols. Everything found becomes a row in the inventory.
  • 4. Polling is scheduled. Every discovered port and sensor gets polled on the system's polling interval from now on, and every polled value goes into its time-series file.
  • 5. The device page fills in. Within a polling cycle or two there are graphs for every port and health graphs for CPU, memory, and sensors. There are also an inventory tab and links to neighbors that the system may offer to add as well.

Discovery is not a one-time event. It re-runs periodically so that a newly patched port, a replaced transceiver, or a new VLAN appears without anyone editing anything. Polling and discovery are separate schedules: polling is frequent and cheap (read the counters), discovery is occasional and heavier (re-enumerate everything).


Tip: the quality of what discovery finds is exactly the quality of the device's SNMP implementation. Before blaming the monitoring, walk the device by hand and see whether the missing sensor or misnamed port is actually there. Some hardware simply does not expose what you hoped, and some exposes it only in a vendor MIB that needs a device definition update.


A graph for every port and sensor


This is the family's signature and the reason network people love it. Other families make you decide what to graph. This one graphs everything discovery found, by default, and lets you ignore what you do not care about. Every interface gets traffic in and out, packets, errors, and discards. Every sensor gets its reading. Every processor and memory pool gets utilization. The device gets availability and response time. You did not ask for any of it, and on Wednesday, when the third floor is slow, it is all there.


Under the hood, the poller reads each port's byte and packet counters on every cycle. It works out the rate since the previous reading, and writes the result into the port's time-series file. That is the same arithmetic every bandwidth graph uses; the family's contribution is doing it for thousands of ports without anyone defining them. Ports can be marked ignored or disabled if you truly do not want them polled. Unused access ports on a large switch are the usual candidates. Ignoring or disabling ports is also how you trim polling load, a topic we return to below.


Graphs are organized the way a network administrator thinks. A port page shows one port in detail. A device page shows all its ports. Aggregate views show every port matching a description across all devices. That is how you see "every uplink in the building" on one screen. Traffic totals per port or group exist for anyone who must answer "how much did that circuit carry last month?"


Alert rules on top


Graphs tell you what happened; alerts tell you now. In this family, alerting is a layer on top of the inventory and the latest polled values. An alert rule is a condition over those tables: it names the fields it cares about and the values that constitute a problem. And it can be scoped to all devices, to a group, or to a single device. The classic first rule, as a sketch:


# Rule: a port that should be up is down
condition:  ports.ifAdminStatus = "up" AND ports.ifOperStatus = "down"
scope:      device group "Core and distribution"
delay:      wait one polling interval before alerting (filters brief flaps)
interval:   remind every hour while the problem persists
recovery:   notify when the condition clears
severity:   critical
transport:  email network-team; chat channel #network-alerts

You will find several pieces in some form in the real rule editor. These include the condition (built from the inventory's fields), the scope, and a delay so that a single bad poll does not page anyone. There is a re-notification interval. There are also one or more transports, which are the delivery methods — email, chat, ticketing, a webhook (a URL that another system listens on), or a script. Recovery notifications are separate and usually wanted, mostly by whoever was paged. The exact syntax and the list of available transports change over time, so treat the sketch as a shape and check the current documentation for the details.


Two related features matter for keeping alerts quiet. Scheduled maintenance lets you declare that a device or group is being worked on so rules do not fire. And the system knows which device is behind which through neighbor discovery and configured parent relationships. Because of that, it can suppress alerts for devices that are unreachable only because an upstream device is down. That is the same dependency idea that the check-based family pioneered, applied to a discovered topology instead of a hand-written one.


Syslog, flows, and other add-ons


Because everything is organized around devices, other data can be attached to the same devices and becomes far more useful than in isolation. Syslog ingestion is the first add-on most people enable. Point your switches and firewalls at the monitoring host as a log destination. Their messages appear on each device's page next to its graphs. A link that flapped at 14:07 sits right beside the log line saying why. The general practice is covered in the syslog and log collection guides.


Flow records — the per-conversation traffic summaries routers and firewalls can export — are typically handled by a companion collector that the system integrates with. That way, a port's traffic graph can be followed by "and here is who was talking." See the flow monitoring guides for what flows are and are not. Other common add-ons include a neighbor map drawn automatically from link-layer discovery data, and billing for circuits. There are also service checks for the occasional non-SNMP thing (using plugins borrowed from the check-based family). There is an API so scripts can read the inventory or add devices (scripts add devices very quickly; hold that thought). Which of these are built in and which are separate installs is the kind of detail that moves; check the current docs.


Strengths and honest limits


Strengths

Time-to-graphs is the headline: for network gear, few things get from nothing to full visibility faster, and the visibility is thorough because discovery is not selective. Breadth of device support is the second. Because device definitions are community-maintained, an enormous range of vendors and models are recognized. Adding support for an odd device usually means contributing a definition rather than writing code. The device-centric UI is the third. Everything about a switch — ports, health, neighbors, logs, alerts, inventory — lives on one page, which is exactly how a network person wants to work.


Limits

Server and application depth is not the focus. The family can monitor servers over SNMP (CPU, memory, disks, interfaces) and some projects offer an agent for a bit more. But if you need process lists, log-file pattern matching, database query timings, or application-level checks in depth, the all-in-one platform or the metrics-first stack are built for that and this family is not. SNMP quality dependence is the second limit. A device with a poor SNMP implementation gives poor data. A device with SNMP disabled is invisible. A vendor that hides the interesting facts in an undocumented MIB leaves you with generic graphs only. And because the system polls everything by default, polling load is a real operational concern rather than a theoretical one, which brings us to the next section.


Operational notes: polling load and distributed pollers


Every device is polled every cycle, and every port and sensor on it is part of that poll. The rule that governs a healthy installation is simple: the time it takes to poll everything must fit comfortably inside the polling interval. If polling a hundred devices takes four minutes and your interval is five, you are fine. If it takes six, the next cycle starts before the last one finishes, queues build, graphs develop gaps, and alerts arrive late. The system reports its own poller timings per device; watching them is the single most important operational habit. And the polling and granularity guides explain the general tradeoff between interval and load.


At Tollgate Foods someone scripted the whole depot address range into the system one Friday. By Monday it knew about four hundred devices, including sixty desk phones, forty printers, and a vending machine. Polling took eleven minutes on a five-minute interval. The uplink graphs, the only ones anyone had wanted, were the ones with gaps. The vending machine's were immaculate.


Levers, roughly in the order you reach for them:


  • Find the slow devices. One badly behaved firewall that takes ninety seconds to answer can hold up a whole cycle. Its poller timing will show it; fix its SNMP settings, increase its timeout, or reduce what is polled from it.
  • Disable what you do not need. Ignore unused ports and turn off discovery and polling modules that make no sense for a device type.
  • Run pollers in parallel. The poller can work on many devices at once. Tuning the number of parallel workers to what the host's CPU and the network can bear is usually the biggest single win.
  • Add distributed pollers. When one host is not enough, or when devices sit at remote sites, additional poller hosts share the work through a common queue. Each takes devices from it, and all write back to the central database and time-series store. This is the family's take on the remote collector pattern in the probes and collectors guide, and the current documentation describes the exact setup.

Learning curve and where it fits


The learning curve is gentle for network administrators, and that is not a small thing. The vocabulary is the vocabulary you already have — devices, ports, VLANs, neighbors, sensors — and the system's job is to fill it in rather than to teach you a new one. The skill that pays off most is SNMP hygiene. That means getting credentials, protocol settings, and access lists right on every device, and knowing how to walk a device when discovery finds less than you expected. If you are not a network person, the learning curve is still gentle but the ceiling is lower. That is because the things you probably want to monitor deeply are not what the family is for.


Where it fits, then, is clear: network teams, or generalist teams whose main monitoring pain is the network. This is especially true where there are many devices from many vendors and nobody has time to define ports by hand. It is an excellent first monitoring system for a small network for that reason. It pairs well with a second tool for servers and applications. It is a natural companion to the metrics-first stack in shops that want deep server metrics and thorough network graphs without forcing either tool to do the other's job.


The concepts in one table


ConceptPlain-language meaningWhy it matters
DeviceA thing with an address that speaks SNMPThe atom; everything else belongs to a device
Device definitionCommunity-maintained description of how to recognize and query a vendor or modelDecides how well discovery understands a device
DiscoveryPeriodic enumeration of what a device has: ports, sensors, storage, neighborsProduces the inventory without manual definition
PollerFrequent collection of current values for everything discoveredProduces the graphs; its timing governs health
PortAn interface on a device, with status, speed, and countersGets its own graphs automatically
SensorA temperature, fan, power, voltage, or optical readingGraphed and alertable without setup
Round-robin time seriesFixed-size files that average old data into coarser bucketsPredictable storage; less detail for long ago
Alert ruleA condition over inventory fields and latest values, with scope and delayTurns graphs into notifications
TransportA delivery method for alerts: email, chat, webhook, scriptHow a rule reaches a person or system
Scheduled maintenanceA declared work window that suppresses alertsKeeps planned changes quiet
Neighbor and parentTopology learned from discovery protocols or configured by handMaps and dependency-aware alerting
Distributed pollerAn additional poller host taking devices from a shared queueScales polling and reaches remote sites

What to check in the current docs before committing


  • Device support for your specific hardware. Search the supported device list for your vendors and models, and read what the definition actually collects for them. "Supported" can mean anything from generic interface graphs to full sensor coverage.
  • The current time-series storage options and the project's recommendation for installations of your size.
  • Alert transports available today and how rules are written in the current rule editor.
  • The distributed poller architecture — what is shared, what runs where, and what happens when a poller host goes offline.
  • Agent and service-check options if you intend to lean on the system for servers, so you know where its depth ends.
  • Which add-ons are integrated versus separate installs: syslog, flows, the neighbor map, and the API.
  • Update cadence and procedure, since projects in this family tend to update frequently and you should know how that interacts with your change process.

Where to go next


One promise, kept literally: give it a device and it will find everything on the device and graph it. Its strengths are time-to-graphs, breadth of device support, and a UI shaped like a network person's head. Its limits are server depth, SNMP dependence, and polling load. They are two sides of the same design choice. On Wednesday, when the third floor is slow, it is the right side.


If the network is your main monitoring pain, start here. The switch port monitoring guides will help you decide which of the thousand graphs you now have deserve an alert rule. If your pain is spread across servers, applications, and the network, continue the Guided Tour of the Open-Source Monitoring Stacks to see how the all-in-one platform and the metrics-first stack divide that work differently.


Put this into practice with SysPeep Monitor

If auto-discovery and a graph for every port is the experience you want, it is worth knowing that the same idea exists in packaged Windows software too. SysPeep Monitor discovers devices and interfaces on your network. It collects over SNMP (with WMI and SSH for servers) and puts graphs, maps, and alerting in one web console with optional remote probes for other sites. It is one more option to weigh against a network-first stack. And the free trial is the honest way to compare them on your own switches.

Download Free TrialLearn About SysPeep