Check Aliveness: Distributed Node Health Monitoring via Heartbeat Timestamps

Question

## Problem

You are building a health monitor for a distributed system. Nodes send heartbeat pings to a central registry. Implement a class that tracks heartbeats and answers liveness queries:

- `ping(node_id, timestamp)` — record that `node_id` was alive at `timestamp`.
- `is_alive(node_id, timestamp, timeout)` — return `True` if the node sent a ping within `[timestamp - timeout, timestamp]`.
- `get_dead_nodes(timestamp, timeout)` — return all nodes that have NOT pinged within the timeout window.

```python
class LivenessMonitor:
    def ping(self, node_id: str, timestamp: int) -> None: ...
    def is_alive(self, node_id: str, timestamp: int, timeout: int) -> bool: ...
    def get_dead_nodes(self, timestamp: int, timeout: int) -> list[str]: ...
```

```
ping("A", 100)
ping("B", 105)
ping("A", 150)
is_alive("A", 160, 20) -> True   # last ping at 150, within 20s
is_alive("B", 160, 20) -> False  # last ping at 105, 55s ago
get_dead_nodes(160, 20)          -> ["B"]
```

## Follow-ups

1. Nodes can re-register after being declared dead. How does your data structure handle that cleanly?
2. How would you scale this to 1 million nodes pinging every second?
3. `get_dead_nodes` is O(n) in your current implementation. Can you make it faster using a sorted structure?
4. What happens if node clocks are skewed by up to 5 seconds relative to the server?

Check Aliveness: Distributed Node Health Monitoring via Heartbeat Timestamps

Question Details

Full Details

About This Question

Topics

More Confluent Interview Questions