AWS Builder Center
LogSourceCoverage to Detect Silent Sources in Wazuh

LogSourceCoverage to Detect Silent Sources in Wazuh

What started as a problem in my Wazuh lab turned into a small monitoring layer for finding log sources that look healthy but have actually stopped sending events.

NUCES FAST ’27 🎓 | Cyber Threat Intelligence (CTI) Researcher | SOC Analyst | VAPT | Cloud Security
While working with Wazuh in my home lab, I noticed something that I think can easily be overlooked in a SOC environment.
An agent being connected does not necessarily mean that it is actually sending useful security telemetry.
That sounds obvious, but when you're looking at a lot of endpoints, it becomes an interesting monitoring problem. If nobody notices, it may seems everything is fine while actually losing visibility from that endpoint.

The idea

I built a small Python-based monitoring layer called LogSourceCoverage on top of Wazuh. The goal was simple.
Don't just ask whether an agent is connected. Ask whether we are actually receiving telemetry from it.
The project monitors both the Wazuh agent's status and the events being produced by the agent.
Based on that, a source can be identified as:
  • Healthy
  • Silent
  • Disconnected
  • Recovered
  • Newly discovered

The problem with only monitoring the heartbeat

One of the first things I looked at was the normal Wazuh agent heartbeat. If an agent is disconnected, that's easy enough to identify. But what happens when the agent is still connected while its event pipeline has stopped?
For example:
Agent: Ubuntu-01
Status: Connected

Last event received:
10 minutes ago
From the heartbeat perspective, everything might look normal. From a telemetry perspective, something is wrong. This is where I wanted to add another layer of visibility.

Zero-event detection

The project monitors the Wazuh  archives.json  event stream and keeps track of the latest event observed from each source. If a source remains connected but doesn't produce events for the configured period, LogSourceCoverage marks it as Silent.
When events start coming in again, it can detect the recovery.
So instead of only seeing:
Connected
I can get something closer to:
Connected → Silent → Recovered

Detecting new sources

I also wanted to know when a source appears that wasn't previously part of the inventory. When LogSourceCoverage sees a previously unknown agent producing events, it can retrieve its metadata and register it in the source inventory.
This gives another useful signal:
"A new log source has appeared in the environment."
That could be useful in environments where new endpoints are constantly being added.

What the monitoring events look like

Instead of generating complicated output, I decided to produce structured JSON events.
For example:
{
"event": "coverage_monitor",
"timestamp": "2026-08-15T10:00:00Z",
"level": "WARNING",
"agent_id": "001",
"agent_name": "ubuntu-agent",
"message": "No events received for 1.6 minutes",
"zero_event_state": "Silent"
}
The reason I went with structured events was that I wanted the output to be easy to consume later. The events can be collected by Wazuh and used for rules, alerts, or dashboard visualizations.

The architecture

At a high level, the project works like this:
Wazuh Manager
|
+---------+---------+
| |
Wazuh API archives.json
| |
+---------+---------+
|
LogSourceCoverage
|
+---------+---------+
| | |
Heartbeat Events Inventory
| | |
+---------+---------+
|
Coverage Events
|
Wazuh Alert
|
Dashboard
The project is intentionally lightweight. I didn't want to replace Wazuh instead add another monitoring layer around it.

What I learned

The biggest thing I took away from this project is that security monitoring is also about monitoring the monitoring itself.
Having an endpoint connected to a SIEM or XDR platform doesn't automatically mean you have complete visibility into that endpoint. There are several things that can go wrong between the endpoint and the monitoring platform.
For now, the project is available on GitHub if anyone wants to look at the implementation or experiment with it.
I'd also be interested to hear from other AWS/security builders:
How do you monitor whether your security telemetry is actually healthy, rather than simply checking whether the endpoint or agent is connected?
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article