Home › Topics › Routing Protocol Health › Route Table Monitoring

Watching the Routing Table: Counts, Defaults, and Surprises


Most of this pillar watches the machinery that maintains the network's map — the neighbor sessions, the change events, the convergence process. This guide watches the map itself. The routing table is the network's live working truth. The diagram on the wall is an aspiration. The configuration file is an intention. The routing table is the actual list a router will consult when the next packet arrives. Whatever anyone believes about the network, the routing table is what it will do.


Watching it is deeply unglamorous. That may be why so few small shops bother — and why the payoff is so out of proportion to the effort. Three cheap checks cover it. Watch the table's size over time. Check the presence of a short list of routes that must exist. Use a scheduled snapshot-and-diff to catch everything else. None of them require protocol expertise. All of them work on any network, including one with no routing protocol at all. That is a point this guide takes seriously in its final section, because plenty of readers run exactly that.


By the end you will be able to read a routing table like a set of plain sentences. You will be able to graph its size and know what the wiggles mean. You will learn to build a presence check for the routes your organization actually depends on. You will also learn to set up a diff that emails you when the map changes overnight. Finally, you will write the one-page "expected state" note that turns future incidents from guesswork into lookup.


In this guide

  • Reading the live map
  • Watching the size
  • Presence checks: the default and the critical shortlist
  • Snapshots and diffs: catching the quiet rewiring
  • Documenting expected state per router
  • A worked surprise: the failover nobody noticed
  • The quiet-network reality: statics-only shops
  • Where to go next

Reading the live map


Every entry in a routing table answers three questions: traffic for which destination network, should be handed to which next stop, and how do I know? The generic display command — on most gear something like show ip route — prints one line per answer. A letter code carries the "how do I know":


core-rtr# show ip route
Codes: C - connected, S - static, O - OSPF, B - BGP

S*  0.0.0.0/0 via 203.0.113.1
C   10.10.1.0/24, port Gi0/1
C   10.10.5.0/30, port Gi0/2
O   10.20.0.0/16 via 10.10.5.2
O   10.44.0.0/16 via 10.10.5.2
B   198.51.100.0/24 via 203.0.113.1

Read each line as a sentence and the mystique evaporates: "traffic for 10.44.x goes to 10.10.5.2, and I know because an OSPF neighbor told me." The source codes matter enormously to monitoring, because they predict how an entry can die. Connected routes (C) exist because a port is up and vanish when it is not. Static routes (S) were typed by a human and vanish only through human action or the loss of the interface they depend on. Learned routes (O and B here) are the lively ones: they appeared because a neighbor advertised them. They will disappear all on their own the moment that neighbor goes silent. That is both the feature and the danger of dynamic routing. One more thing to notice before moving on: this router holds six routes. Remember that kind of number; it is about to become a monitoring signal.


One nuance completes the picture: the table shows winners. Several sources may offer a path to the same destination — a static entry and a learned one, say. The router then picks a single winner using built-in preference rules. Only the winner appears in the table and carries traffic. This matters to monitoring because a route can be present yet be the wrong route. A forgotten static might quietly outrank the dynamic path everyone assumes is in charge, for instance. That is why the checks later in this guide look beyond whether an entry exists. They also check its source code and its next hop. Those parts reveal which version of the road won.


Watching the size


The simplest routing-table check is a single number per router: how many routes are in the table right now? You can collect it over SNMP where the device exposes a count, or by scheduling a read-only login that runs the display command and counts lines. Poll it every few minutes, and above all, graph it. A healthy network draws the most boring graph you own: a flat line for weeks. Then comes one clean step up or down on the day you actually changed something. Then it is flat again. Frame that graph; it is what competence looks like.


If your gear offers per-source counts, collect those too. These show how many routes are static and how many are learned from each protocol. They split one ambiguous signal into several precise ones. A drop in learned routes points at a neighbor or a far site. A drop in statics points at a human or a downed interface. Total count alone cannot tell you which story you are in. Where per-source counts are not exposed, the nightly snapshot described later recovers the same information, since the source codes travel with every line.


The interesting shapes are the unplanned ones. A sudden shrink means the router lost a source of information. A neighbor died and took all of its advertised routes with it, or someone deleted more than they meant to. The session side of that story is in monitoring neighbor state. A sudden growth means the router learned things it should not have. A misconfiguration could be announcing extra networks. Or a far end — a provider, a partner, another site — could be sharing far more of its map than agreed. The trade politely calls that a leak. Leaks are not just clutter: small routers have finite room, and a flood of unexpected routes can genuinely overwhelm modest gear. And a sawtooth — dip, recover, dip, recover — is flapping, which has its own guide.


Alert on change, not on a magic number. There is no universally correct route count; the correct count for your core router is "whatever it has steadily been." Warn when the count drifts outside its recent normal band. Alert when it jumps or drops by more than a handful at once outside a maintenance window. And alert hard if it ever approaches the device's capacity. The baseline does the thinking; you just have to have been collecting it.


Presence checks: the default and the critical shortlist


Size is a blunt instrument — a table can hold a perfectly normal forty-two routes while missing the one that matters. So a few entries deserve individual existence checks. The first is not negotiable: the default route, written 0.0.0.0/0. It is the map's "everything else goes here" entry. In most networks, it is the road to the internet. When it disappears, you get a distinctly confusing outage: every internal device pings fine, every dashboard is green, and nobody can reach anything outside. A presence check is binary, cheap, and unambiguous — the route exists or it does not — and it turns that confusing hour into a ten-second diagnosis.


Beyond the default, build a shortlist of routes that each stand for something. Include one route representing each branch site and the subnet behind each VPN tunnel. Add the path to your recovery site and anything a critical application depends on. The discipline is keeping the list short — you are not monitoring all routes individually, only the few whose absence equals a business problem:


Route to checkStands forIf it goes missing
0.0.0.0/0 (default)The way out — usually the internetEverything external breaks, confusingly
10.44.0.0/16The branch officeOne site falls off the network, often silently
10.99.8.0/24The vendor VPN tunnelThe tunnel is dead no matter what its status light claims
10.60.0.0/16The recovery siteYour disaster plan has no road to drive on

Mechanically, a presence check is a scheduled question: "does the table contain this exact destination?" It is asked over SNMP or via that same read-only login, with an alert on absence. Severity should follow the "stands for" column, not the route itself. A missing default route is a drop-everything page. A missing recovery-site route is quiet today but catastrophic on exactly the wrong day.


Where should presence checks live? Not on every device. Run them on the routers where the decision actually happens. That means the core router or layer 3 switch that user traffic crosses first. It also means the WAN edge that owns the way out. If the default route exists at the core, the campus can reach the exit. If it exists at the edge, the exit leads somewhere. Two well-placed checks cover the whole journey, and adding ten more mostly adds ten more things to maintain.


Snapshots and diffs: catching the quiet rewiring


Size and presence still miss a whole category: the change that keeps the count identical and the shortlist present, but rewires where something points. A route whose next hop silently changes passes both checks while sending your traffic down a different road. The answer is the third check. It is the best effort-to-coverage trade in this guide. Snapshot the entire table on a schedule, compare it with the previous snapshot, and alert on any difference. You do not have to predict what "wrong" will look like. You alert on "different" and let a human judge. That is precisely the right division of labor between scripts and admins.


# nightly, for each router, via a read-only account
fetch the route table            > today.txt
strip the always-changing noise  (ages, counters)
diff yesterday.txt today.txt     > changes.txt
if changes.txt is not empty:     email it to yourself
rotate: today.txt becomes yesterday.txt

If that shape looks familiar, it should: it is the same pattern as path change detection, one layer down. Paths are what the map produces; the routing table is the map itself. Both are watched the same way — scheduled capture, normalize, diff, small email. If you have built either one, the other is an evening's work with the serial numbers filed off.


Three wrinkles learned the annoying way. First, normalize before diffing: route ages and packet counters change constantly. If you leave them in, every diff fires and you will unsubscribe from your own alert within a week. Second, pick a humane cadence: nightly is plenty for networks that change rarely. Take an extra manual snapshot before every maintenance window and another afterward. That pair turns "wait, what did we change?" into a printout. Third, keep history: a month of dated snapshots is a time machine. Then "when did this route first appear?" becomes a question you can actually answer instead of a séance.


Scaling this to several routers is pleasantly dull. Use one snapshot file per router, one loop, and a single combined morning email rather than five separate ones. A summary line per router ("no changes" or the diff itself) reads in ten seconds with coffee. The empty version of that email matters more than it looks, too. "No changes anywhere" is your daily proof that the collection itself still works. A snapshot job that silently died would otherwise report eternal, comforting, fictional stability.


Tip: give the snapshot job a read-only account on the routers. Automation that can only look is automation that cannot hurt you at two in the morning. And it makes the security review of "a script logs into our routers nightly" refreshingly short.


Documenting expected state per router


All three checks lean on the same quiet prerequisite: knowing what the table is supposed to contain. That knowledge usually lives in one senior head, or nowhere. Fix it with what you might call a routing birth certificate. That is a one-page note per router, written on a healthy day, stating what normal looks like. During an incident it converts "does six routes seem right to you?" from a guess into a lookup:


FieldExample entry
Routercore-rtr
Expected neighborswan-rtr (fiber uplink), bldg2-sw (campus fiber)
Normal route count40 to 44
Must-have routesdefault; 10.44.0.0/16 (branch); 10.99.8.0/24 (vendor VPN)
Default route points via203.0.113.1 (primary); 198.51.100.1 if on backup
Last reviewedAfter the branch circuit upgrade

Keep it wherever three-in-the-morning-you will actually find it. And add "update the birth certificates" to your change checklist so the notes age with the network instead of against it. Notice how it dovetails with the expected-neighbor inventory from the neighbor guide. Together they describe, on paper, the network your monitoring is checking reality against. That is the whole trick of this pillar, twice.


A worked surprise: the failover nobody noticed


Here is the morning that pays for the whole setup. The nightly diff email is waiting for you, two lines long:


- 0.0.0.0/0 via 203.0.113.1     (removed)
+ 0.0.0.0/0 via 198.51.100.1    (added)

No tickets. The internet works. Every reachability check is green. But the map says the default route moved from the primary provider path to the backup overnight. You check neighbor state: the session toward the primary provider has been down since 02:41. The log line says the interface dropped — the circuit itself died in the small hours. Failover worked exactly as designed. Convergence took its few seconds while the building slept. By morning the network was quietly running on its spare. The only witness was a two-line diff.


Now run the counterfactual. Without the diff, nothing surfaces this. The presence check passes — a default route exists all along, just via the wrong road. The route count never moved. Users feel nothing, so nobody reports anything. The network runs on the backup — possibly slower, possibly metered, definitely without a spare. That lasts for however many weeks it takes the backup to hiccup too. At that point you get a hard outage plus a cold trail. Instead, you open a ticket with the provider at nine in the morning and quote the exact failure time from your own logs. You watch the session restore. Then you verify the failback with the before-and-after comparison from the convergence guide. One quiet incident, fully witnessed, closed before lunch. And it gives a concrete answer to why all three checks exist. The count missed it, the presence check missed it, and the diff caught it.


The quiet-network reality: statics-only shops


Now the honesty this library owes you: maybe your network runs no routing protocol at all. No neighbors, no learned routes, a table you can read in one screen. Is this guide still for you? Genuinely yes — scaled down, not switched off. Your table may be small, but the few routes in it carry everything, and two of this guide's checks apply almost unchanged. The default route on your firewall still deserves a presence check, because it can still be lost to a bad edit or a failed upstream. And — a detail that surprises people — even "static" networks often have routes that come and go on their own. Many firewalls insert and remove the routes for VPN tunnels dynamically as tunnels rise and fall. So a vanished tunnel route is a live, monitorable symptom in a shop with no routing protocol anywhere.


The snapshot-and-diff earns its keep here too, mostly against humans. The classic statics-only incident is the temporary route someone added during troubleshooting — pointing a subnet at a test box, say. It then lives forever because nothing tracks it, until months later it explains a very strange afternoon. A weekly diff (nightly is overkill when the table changes four times a year) surfaces the stowaway the next time it runs. Scale everything to fit: presence checks on the default and each tunnel route, a weekly diff, a ten-line birth certificate. And if the organization someday grows into dynamic routing, your monitoring is already the right shape — the table just gets longer.


Where to go next


The routing table in one breath: it is the live map and the final word on what the network will do. Watch its size for wiggles. Check the presence of the default and the shortlist that stands for your business. And diff scheduled snapshots to catch the quiet rewiring the other two miss. Add the one-page expected-state note per router, and "is the map right?" becomes a question your tooling answers every night while you sleep.


If you landed here first, the plain-language routing guide backfills every concept this one leaned on. The rest of Routing Protocol Health covers the sessions, stability signals, and convergence behavior. These explain why the map changes when it does. Start the graph, schedule the diff, and enjoy owning the most boring — and most trustworthy — flat line in your monitoring.


Put this into practice with SysPeep Monitor

Route counts are exactly the kind of number worth polling on a schedule. SysPeep Monitor does the faithful part for you: it collects metrics from your routers over SNMP and SSH. It graphs them so a drift or a step stands out, and alerts the moment a threshold is crossed. Meanwhile, your snapshot script keeps its diff duty. The free trial runs on any Windows machine.

Download Free TrialLearn About SysPeep