Home › Topics › Core Services: NTP, RADIUS, LDAP/AD › RADIUS Monitoring

RADIUS: Monitoring the Gatekeeper of Wi-Fi and VPN


"The Wi-Fi is down." You check: every access point is up and every radio is broadcasting. The network name is right there on everyone's screen, with signal bars at full. And yet nobody can get on. The network is fine in every way you know how to measure — because the thing that broke is not the network. It is the bouncer at the door: a service called RADIUS, which every access point quietly consults before letting anyone in. Almost nobody monitors it until the day it teaches them to.


RADIUS sits in a strange blind spot. It guards the front door of your Wi-Fi, your VPN, and often your switch and firewall admin logins. That list amounts to "everything people notice immediately". Yet RADIUS runs as a modest service on a box nobody thinks about. Its failures always get blamed on the doors it guards rather than on the bouncer itself.


This guide fixes the blind spot. You will learn what RADIUS actually does in plain language and why its failures disguise themselves as Wi-Fi and VPN problems. You will learn the monitoring approach that works: synthetic authentication tests as the gold standard and real verification of your redundant pair. You will learn about auth latency as an early-warning metric and the log signals that flag trouble brewing. By the end, "the Wi-Fi is down" will take you two minutes to confirm or refute at the source.


In this guide

  • What RADIUS actually does
  • Why RADIUS failures wear a disguise
  • The gold standard: synthetic authentication tests
  • The dead-secondary trap
  • Auth latency: the metric that whispers before it screams
  • Log signals worth watching
  • The dependencies behind the gatekeeper
  • Your RADIUS monitoring starter kit
  • Where to go next

What RADIUS actually does


Picture a club with many doors and one bouncer. The doors are your access points, your VPN concentrator, your switches' login prompts. None of them keeps a guest list of its own. Imagine maintaining user accounts on forty access points. So when someone shows up at a door with credentials, the door radios the bouncer: "I have someone here claiming to be dana with this password/certificate. Let them in?" The bouncer checks the list and radios back yes or no. The bouncer is RADIUS.


The name stands for Remote Authentication Dial-In User Service, which tells you it was born in the era of modems and dial-up. The technology it served died. The job it does — one central service answering "may this person come in?" for many doors — turned out to be timeless. So RADIUS outlived its own name. In protocol terms, the door is formally a NAS, network access server — an unfortunate acronym collision with storage boxes. It sends an Access-Request over UDP. The server answers Access-Accept, Access-Reject, or Access-Challenge (meaning "ask them for more," which is how multi-step and certificate-based logins flow). Door and server authenticate each other with a pre-agreed password called the shared secret. A request from a door the server does not recognize, or with the wrong secret, is typically ignored. Remember that behavior — it stars in a failure mode later.


It helps to watch one login travel the chain. A laptop joins the corporate Wi-Fi: it associates with the access point, which immediately blocks all traffic except the authentication conversation. The AP wraps the laptop's credentials into an Access-Request and sends it to the RADIUS server. RADIUS looks up the account — usually by querying the directory. It verifies the credential and checks any policies (right group? allowed on this network at this hour?). It returns Access-Accept, often with instructions riding along. These might say: put this user on VLAN 20, apply this session timeout. The AP opens the door accordingly. Total elapsed time: well under a second when everything is healthy. Every hop in that little journey is a place where "the Wi-Fi" can break while no access point is at fault. That includes AP to server, server to directory, policy evaluation, and the return trip.


Two more facts complete the picture. First, RADIUS rarely knows the answers itself. In most orgs it checks credentials by asking the directory (Active Directory or another LDAP source). That makes it a middleman with a dependency of its own. Second, RADIUS also handles accounting. The doors report who connected, when, and for how long. That matters for troubleshooting and auditing but is a side character in this guide. The starring role is authentication.


Why RADIUS failures wear a disguise


Nobody experiences RADIUS. Users experience doors. So when the bouncer stops answering, every complaint names a door: "the Wi-Fi is broken," "the VPN is down," "I can't log into the switch." Each of those has its own troubleshooting universe, its own dashboards, and sometimes its own team. A RADIUS failure sends everyone into the wrong universe at once. Wi-Fi troubleshooting is a deep field of signal and airtime questions (the guide on measuring what Wi-Fi users actually experience covers it properly). VPN problems have a playbook of their own. But when the true cause is RADIUS, every hour spent in those universes is an hour wasted.


Fortunately, a RADIUS outage has a signature. Once you know it you can spot it from across the room: everything works except getting on. Access points up, radios broadcasting, VPN portal reachable, switches switching — but new connections fail at the credential step. Even more distinctive is the drip pattern: people already connected stay connected for a while, because they are not re-asking the bouncer. Then they drop off one by one as their sessions come up for periodic re-authentication. The helpdesk version reads: "Wi-Fi works for people who never left their desk, but everyone coming back from lunch is locked out." That sentence, verbatim, is RADIUS until proven otherwise.


One disguise deserves special mention because it can bite you mid-incident: many orgs point switch, router, and firewall admin logins at RADIUS too. During a RADIUS outage, the credentials you would use to investigate the network are themselves behind the broken lock. This is why every device pointed at RADIUS should keep a local fallback account with a strong, vaulted password. It is also why that fallback should be tested occasionally, not merely believed in. Discovering the local password is wrong during the lockout is a genre of bad afternoon all its own.


The gold standard: synthetic authentication tests


You could monitor RADIUS the way people monitor most things — ping the server, check the service is running. You would be measuring the box, not the bouncer. The service can be "running" while the shared secret is wrong, the directory link is broken, or the certificate has expired. The only check that proves the gatekeeper works is the one that walks up to the gate: a synthetic authentication test. In that test, a dedicated test account actually authenticates, on a schedule. And the result and response time are recorded.


A passing synthetic auth is a wonderfully complete statement. It proves the server is up, the service is listening, and the request was accepted (so the secret is right). It proves the directory behind it answered, and the whole exchange finished within tolerance. One green check covers the entire chain; one red check tells you the chain is broken somewhere — before a human hits it. The test tooling is humble; the classic command-line client ships with the most common open-source RADIUS server:


# Ask radius1 directly: authenticate the test account
radtest svc-radprobe PASSWORD radius1.corp.example 0 SHARED_SECRET

# Expected happy answer:
#   Received Access-Accept  ...
# A timeout means the door got no answer at all
# An Access-Reject means it answered, and said no — different problem

Most monitoring systems can run a RADIUS probe or wrap a script like this into a scheduled check. The distinction the comments hint at is worth internalizing. A timeout means dead server, blocked port, or wrong shared secret (remember, unknown doors get silence). A reject means RADIUS is alive and declining — look at the account, the password, or the policy. Your check should treat both as failures but record which one, because they send you down different roads.


Give the test account the hygiene it deserves: an obvious name (svc-radprobe beats jsmith2), no group memberships beyond what the test needs, and no access to anything valuable. Give it documentation so a future security review does not have a heart attack over a mystery account. The account logs in every two minutes from the monitoring server.


Tip: put a reminder on the test account's password expiry — or exempt it from expiry per your security policy. A synthetic check that starts failing every year on schedule, because its own password lapsed, trains people to ignore the one alert that exists to be believed.


The dead-secondary trap


Almost every org runs two RADIUS servers, because everyone knows the gatekeeper matters. Almost every access device is configured with both: primary and secondary. And an alarming fraction of those secondaries are dead — and have been for months. The service stopped after a patch reboot, or a firewall rule tightened, or someone rebuilt the box and the shared secret changed. Nothing notices, because nothing ever talks to the secondary while the primary is healthy. Redundancy that is never exercised is not redundancy; it is a rumor.


The trap springs on the worst possible day: the day you take the primary down for maintenance, confident in the failover. Then the org discovers together that the backup bouncer retired last spring. The outage happens during a planned window, with your name on the change record. This particular embarrassment has a hundred variants and one cause: nobody ever tested the secondary as if it were the only server.


The fix costs nothing once synthetic tests exist: aim them. Run the synthetic authentication against each server individually, by its own address. Do not aim at the failover pair, where the primary will cheerfully answer on the secondary's behalf and hide its corpse. Two servers, two checks, always. And once a maintenance cycle, make the failover real. During a quiet window, stop the primary deliberately and watch the doors switch to the secondary while you drink coffee. Ten calm minutes of planned failover buys you out of the unplanned kind.


Auth latency: the metric that whispers before it screams


Between "working" and "down" lies "slow" — and for RADIUS, slow is operationally identical to down, because of who is waiting. An access point that queries RADIUS gives it a handful of seconds, then gives up and retries or rejects the client. Your VPN concentrator behaves the same. So a RADIUS server might take six seconds to answer because the directory behind it is grinding. Or that delay might come from the box swapping, or a database index that went sideways. The server then produces intermittent edge failures while looking healthy to any test without a stopwatch. An admin who tests by hand sees it work ("took a moment, but fine") and closes the ticket. The access points, less patient, keep timing out.


This is why your synthetic test must record response time, not just pass/fail. Graph it. Healthy RADIUS answers simple authentications in tens to hundreds of milliseconds; the graph will show you your own normal within a week. Then alert on drift — when latency runs several times its baseline, and certainly as it approaches the edge-device timeout. That graph climbing is the sound of the gatekeeper whispering that something behind the desk is wrong. You will often see it climb during the morning login storm first. Latency is fine at scale of one, ugly at scale of everyone-at-nine. That pattern points squarely at the directory or the server's own resources. That pattern hands you the rarest gift in operations: a failure announcing itself before the failing.


Log signals worth watching


RADIUS logs are chatty in useful ways. You do not need to read them daily. You need a few patterns watched automatically. That is because each one is an early chapter of a story you would rather finish now than during an outage:


Log signalWhat it usually meansWhat to do
Reject spike for one accountA device with a saved old password retrying in a loop — classically a phone after a password changeFind the device before lockout policies find the user
Reject spike across many accountsA policy or group change gone wrong — or a password-guessing attemptCheck recent changes first; treat as security if none
Requests from an unknown clientA new AP or switch added without registering it (or its shared secret) on the serverRegister it properly; silence-to-the-door looks like an outage there
Accounting gone quiet from one doorThat NAS lost its path to RADIUS — firewall change, VLAN move, device issueInvestigate the door; users there may be running on cached grace
Auth volume flatlines to zeroNobody is asking — the doors have failed over elsewhere, or the network path brokeCheck the partner server's volume and the path between

That last row deserves a note: silence is a signal. A RADIUS server whose request volume drops to zero has not become healthy; it has become irrelevant, and you want to know which. If your monitoring can track a simple rate — authentications per minute per server — you gain a check that catches failures no other test sees. Those include the sneaky ones where the servers are fine and the network between them and the doors is not.


The dependencies behind the gatekeeper


Monitor RADIUS perfectly and you have still only covered the front desk — because the bouncer does not own the guest list. When a synthetic auth fails or slows, the cause frequently lives one layer down, in the dependencies RADIUS consults to do its job:


  • The directory. In most networks, RADIUS validates credentials against Active Directory or another LDAP directory. So directory sickness surfaces as authentication sickness, with RADIUS taking the blame. The companion guide on LDAP and Active Directory health covers watching that layer. The short version is that your RADIUS monitoring and your directory monitoring are two chapters of one story.
  • The server's certificate. Modern Wi-Fi authentication wraps the credential exchange in a TLS tunnel. That means your RADIUS server presents a certificate that every client device checks. And a RADIUS certificate expiring is the classic way an entire org's Wi-Fi breaks at midnight while every server dashboard stays green. See the certificate and expiry monitoring guides for making that impossible.
  • Names and time. RADIUS finds its directory by name, and certificate checks assume sane clocks — so the deepest foundations of the dependency iceberg sit under this service too.

The practical takeaway: when the gatekeeper check goes red, glance down the chain before restarting services. A failing LDAP bind check plus a failing RADIUS check is a directory problem wearing two costumes. Knowing that in thirty seconds is precisely why you monitor both layers.


Your RADIUS monitoring starter kit


Everything above condenses into an afternoon of setup. In rough priority order:


  • Step 1: create the probe account. Minimal rights, obvious name, documented, its password expiry handled deliberately.
  • Step 2: synthetic auth against each server by address. Every one to five minutes, recording pass/fail, reject-versus-timeout, and response time. Alert on two consecutive failures.
  • Step 3: latency threshold and trend. Alert when auth time runs several times its baseline or approaches your edge devices' timeout.
  • Step 4: host checks underneath. CPU, memory, disk, and service status on both RADIUS servers — ordinary server monitoring, still necessary.
  • Step 5: log-pattern watches. Reject spikes, unknown clients, and per-server auth volume, including the flatline-to-zero case.
  • Step 6: calendar the failover drill. Once per maintenance cycle, stop the primary on purpose and watch the secondary carry the load.

Steps 1 and 2 alone put you ahead of most networks. They are also the two that pay off first. The very next time someone declares the Wi-Fi broken, you will glance at two synthetic checks. You will know — not guess, know — whether the gatekeeper is answering, and how fast, at each door of the club.


Where to go next


You now have the full RADIUS monitoring recipe: synthetic authentications against each server individually and latency graphed and alerted on drift. You have log patterns watched for the stories they tell early, and the dependencies underneath held to the same standard. When logins do break anyway — RADIUS is one hop in a longer chain — the authentication-path troubleshooting playbook walks the whole path hop by hop. The rest of the foundation family is mapped in Core Services: NTP, RADIUS, LDAP/AD. The bouncer guards your doors; somebody should be guarding the bouncer.


Put this into practice with SysPeep Monitor

RADIUS never fails alone — behind it sit servers, a directory, and the network between. SysPeep Monitor auto-discovers those pieces and tracks their health over SNMP, WMI, and SSH. Its dependency-aware alerting means a gatekeeper problem reaches you as one clear alert instead of a storm of Wi-Fi complaints. The free trial installs on any Windows machine.

Download Free TrialLearn About SysPeep