MACRO NEPAL
Circuit Breaker Dashboard in Java
awiskar acharya
November 17, 2025
10:36 am

Overview

A Circuit Breaker Dashboard provides real-time monitoring and visualization of circuit breaker states across microservices. It helps track system health, failure rates, and operational metrics.

Architecture Components

  • Circuit Breaker Registry: Central registry for all circuit breakers
  • Metrics Collector: Gathers metrics from circuit breakers
  • Dashboard API: REST API for dashboard data
  • Web Dashboard: Real-time UI for visualization
  • Alerting System: Notifications for state changes

Core Implementation

1. Circuit Breaker Interface and Implementation

public interface CircuitBreaker {
String getName();
State getState();
Metrics getMetrics();
boolean allowRequest();
void onSuccess();
void onFailure();
void onTimeout();
enum State {
CLOSED, OPEN, HALF_OPEN
}
class Metrics {
private final long totalRequests;
private final long failedRequests;
private final long timeoutRequests;
private final double failureRate;
private final long lastFailureTimestamp;
private final long lastSuccessTimestamp;
// Constructor, getters, builder pattern
public Metrics(long totalRequests, long failedRequests, long timeoutRequests, 
double failureRate, long lastFailureTimestamp, long lastSuccessTimestamp) {
this.totalRequests = totalRequests;
this.failedRequests = failedRequests;
this.timeoutRequests = timeoutRequests;
this.failureRate = failureRate;
this.lastFailureTimestamp = lastFailureTimestamp;
this.lastSuccessTimestamp = lastSuccessTimestamp;
}
// Getters
public long getTotalRequests() { return totalRequests; }
public long getFailedRequests() { return failedRequests; }
public long getTimeoutRequests() { return timeoutRequests; }
public double getFailureRate() { return failureRate; }
public long getLastFailureTimestamp() { return lastFailureTimestamp; }
public long getLastSuccessTimestamp() { return lastSuccessTimestamp; }
public static class Builder {
private long totalRequests;
private long failedRequests;
private long timeoutRequests;
private double failureRate;
private long lastFailureTimestamp;
private long lastSuccessTimestamp;
public Builder totalRequests(long totalRequests) {
this.totalRequests = totalRequests;
return this;
}
public Builder failedRequests(long failedRequests) {
this.failedRequests = failedRequests;
return this;
}
public Builder timeoutRequests(long timeoutRequests) {
this.timeoutRequests = timeoutRequests;
return this;
}
public Builder failureRate(double failureRate) {
this.failureRate = failureRate;
return this;
}
public Builder lastFailureTimestamp(long lastFailureTimestamp) {
this.lastFailureTimestamp = lastFailureTimestamp;
return this;
}
public Builder lastSuccessTimestamp(long lastSuccessTimestamp) {
this.lastSuccessTimestamp = lastSuccessTimestamp;
return this;
}
public Metrics build() {
return new Metrics(totalRequests, failedRequests, timeoutRequests, 
failureRate, lastFailureTimestamp, lastSuccessTimestamp);
}
}
}
}

2. Resilience4j-based Circuit Breaker Implementation

import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.event.CircuitBreakerEvent;
import java.time.Duration;
import java.util.concurrent.atomic.AtomicLong;
public class Resilience4jCircuitBreaker implements CircuitBreaker {
private final String name;
private final CircuitBreaker resilience4jCircuitBreaker;
private final AtomicLong totalRequests = new AtomicLong(0);
private final AtomicLong failedRequests = new AtomicLong(0);
private final AtomicLong timeoutRequests = new AtomicLong(0);
private volatile long lastFailureTimestamp = 0;
private volatile long lastSuccessTimestamp = 0;
public Resilience4jCircuitBreaker(String name, CircuitBreakerConfig config) {
this.name = name;
this.resilience4jCircuitBreaker = CircuitBreakerRegistry.of(config).circuitBreaker(name);
// Register event listeners for metrics
this.resilience4jCircuitBreaker.getEventPublisher()
.onSuccess(event -> {
lastSuccessTimestamp = System.currentTimeMillis();
totalRequests.incrementAndGet();
})
.onError(event -> {
lastFailureTimestamp = System.currentTimeMillis();
totalRequests.incrementAndGet();
failedRequests.incrementAndGet();
})
.onCallNotPermitted(event -> {
totalRequests.incrementAndGet();
})
.onStateTransition(event -> {
System.out.println("CircuitBreaker " + name + " changed state from " + 
event.getStateTransition().getFromState() + " to " + 
event.getStateTransition().getToState());
});
}
public static CircuitBreakerConfig defaultConfig() {
return CircuitBreakerConfig.custom()
.failureRateThreshold(50) // 50% failure rate
.slowCallRateThreshold(50) // 50% slow calls
.slowCallDurationThreshold(Duration.ofSeconds(2))
.waitDurationInOpenState(Duration.ofSeconds(60))
.permittedNumberOfCallsInHalfOpenState(10)
.minimumNumberOfCalls(10)
.slidingWindowType(CircuitBreakerConfig.SlidingWindowType.COUNT_BASED)
.slidingWindowSize(100)
.build();
}
@Override
public String getName() {
return name;
}
@Override
public State getState() {
switch (resilience4jCircuitBreaker.getState()) {
case CLOSED: return State.CLOSED;
case OPEN: return State.OPEN;
case HALF_OPEN: return State.HALF_OPEN;
case FORCED_OPEN: return State.OPEN;
case DISABLED: return State.CLOSED;
default: return State.CLOSED;
}
}
@Override
public Metrics getMetrics() {
long total = totalRequests.get();
long failed = failedRequests.get();
long timeout = timeoutRequests.get();
double failureRate = total > 0 ? (double) failed / total * 100 : 0.0;
CircuitBreaker.Metrics resilienceMetrics = resilience4jCircuitBreaker.getMetrics();
return new Metrics.Builder()
.totalRequests(total)
.failedRequests(failed)
.timeoutRequests(timeout)
.failureRate(failureRate)
.lastFailureTimestamp(lastFailureTimestamp)
.lastSuccessTimestamp(lastSuccessTimestamp)
.build();
}
@Override
public boolean allowRequest() {
return resilience4jCircuitBreaker.tryAcquirePermission();
}
@Override
public void onSuccess() {
resilience4jCircuitBreaker.onSuccess(System.nanoTime(), Duration.ofNanos(0));
}
@Override
public void onFailure() {
resilience4jCircuitBreaker.onError(System.nanoTime(), Duration.ofNanos(0), 
new RuntimeException("Operation failed"));
}
@Override
public void onTimeout() {
timeoutRequests.incrementAndGet();
resilience4jCircuitBreaker.onError(System.nanoTime(), Duration.ofNanos(0), 
new RuntimeException("Operation timeout"));
}
// Additional methods for dashboard integration
public CircuitBreaker.State getDetailedState() {
return resilience4jCircuitBreaker.getState();
}
public io.github.resilience4j.circuitbreaker.CircuitBreaker.Metrics getResilienceMetrics() {
return resilience4jCircuitBreaker.getMetrics();
}
}

3. Circuit Breaker Registry

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
public class CircuitBreakerRegistry {
private static CircuitBreakerRegistry instance;
private final Map<String, CircuitBreaker> circuitBreakers = new ConcurrentHashMap<>();
private final List<CircuitBreakerStateListener> listeners = new CopyOnWriteArrayList<>();
private CircuitBreakerRegistry() {}
public static synchronized CircuitBreakerRegistry getInstance() {
if (instance == null) {
instance = new CircuitBreakerRegistry();
}
return instance;
}
public CircuitBreaker register(String name, CircuitBreakerConfig config) {
return circuitBreakers.computeIfAbsent(name, 
k -> new Resilience4jCircuitBreaker(name, config));
}
public CircuitBreaker getCircuitBreaker(String name) {
return circuitBreakers.get(name);
}
public Collection<CircuitBreaker> getAllCircuitBreakers() {
return Collections.unmodifiableCollection(circuitBreakers.values());
}
public Map<String, CircuitBreaker> getCircuitBreakersByService(String serviceName) {
return circuitBreakers.entrySet().stream()
.filter(entry -> entry.getKey().startsWith(serviceName + "."))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
}
public void addListener(CircuitBreakerStateListener listener) {
listeners.add(listener);
}
public void removeListener(CircuitBreakerStateListener listener) {
listeners.remove(listener);
}
public void notifyStateChange(CircuitBreaker circuitBreaker, 
CircuitBreaker.State oldState, 
CircuitBreaker.State newState) {
for (CircuitBreakerStateListener listener : listeners) {
listener.onStateChange(circuitBreaker, oldState, newState);
}
}
public void notifyMetricsUpdate(CircuitBreaker circuitBreaker) {
for (CircuitBreakerStateListener listener : listeners) {
listener.onMetricsUpdate(circuitBreaker);
}
}
public interface CircuitBreakerStateListener {
void onStateChange(CircuitBreaker circuitBreaker, 
CircuitBreaker.State oldState, 
CircuitBreaker.State newState);
void onMetricsUpdate(CircuitBreaker circuitBreaker);
}
// Configuration class
public static class CircuitBreakerConfig {
private double failureRateThreshold = 50.0;
private int slowCallRateThreshold = 50;
private long slowCallDurationThreshold = 2000; // ms
private long waitDurationInOpenState = 60000; // ms
private int permittedNumberOfCallsInHalfOpenState = 10;
private int minimumNumberOfCalls = 10;
private int slidingWindowSize = 100;
// Getters and setters
public double getFailureRateThreshold() { return failureRateThreshold; }
public void setFailureRateThreshold(double failureRateThreshold) { 
this.failureRateThreshold = failureRateThreshold; 
}
public int getSlowCallRateThreshold() { return slowCallRateThreshold; }
public void setSlowCallRateThreshold(int slowCallRateThreshold) { 
this.slowCallRateThreshold = slowCallRateThreshold; 
}
public long getSlowCallDurationThreshold() { return slowCallDurationThreshold; }
public void setSlowCallDurationThreshold(long slowCallDurationThreshold) { 
this.slowCallDurationThreshold = slowCallDurationThreshold; 
}
public long getWaitDurationInOpenState() { return waitDurationInOpenState; }
public void setWaitDurationInOpenState(long waitDurationInOpenState) { 
this.waitDurationInOpenState = waitDurationInOpenState; 
}
public int getPermittedNumberOfCallsInHalfOpenState() { 
return permittedNumberOfCallsInHalfOpenState; 
}
public void setPermittedNumberOfCallsInHalfOpenState(int permittedNumberOfCallsInHalfOpenState) { 
this.permittedNumberOfCallsInHalfOpenState = permittedNumberOfCallsInHalfOpenState; 
}
public int getMinimumNumberOfCalls() { return minimumNumberOfCalls; }
public void setMinimumNumberOfCalls(int minimumNumberOfCalls) { 
this.minimumNumberOfCalls = minimumNumberOfCalls; 
}
public int getSlidingWindowSize() { return slidingWindowSize; }
public void setSlidingWindowSize(int slidingWindowSize) { 
this.slidingWindowSize = slidingWindowSize; 
}
}
}

Dashboard Backend API

1. Spring Boot Dashboard Controller

import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import org.springframework.http.MediaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.*;
import java.util.stream.Collectors;
@RestController
@RequestMapping("/api/dashboard")
@CrossOrigin(origins = "*") // For frontend development
public class CircuitBreakerDashboardController {
private final CircuitBreakerRegistry registry;
private final MetricsService metricsService;
private final AlertService alertService;
private final ObjectMapper objectMapper;
public CircuitBreakerDashboardController(CircuitBreakerRegistry registry,
MetricsService metricsService,
AlertService alertService,
ObjectMapper objectMapper) {
this.registry = registry;
this.metricsService = metricsService;
this.alertService = alertService;
this.objectMapper = objectMapper;
}
@GetMapping("/circuit-breakers")
public ResponseEntity<List<CircuitBreakerDTO>> getAllCircuitBreakers() {
List<CircuitBreakerDTO> circuitBreakers = registry.getAllCircuitBreakers().stream()
.map(this::toDTO)
.collect(Collectors.toList());
return ResponseEntity.ok(circuitBreakers);
}
@GetMapping("/circuit-breakers/{name}")
public ResponseEntity<CircuitBreakerDTO> getCircuitBreaker(@PathVariable String name) {
CircuitBreaker cb = registry.getCircuitBreaker(name);
if (cb == null) {
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(toDTO(cb));
}
@GetMapping("/circuit-breakers/service/{serviceName}")
public ResponseEntity<Map<String, CircuitBreakerDTO>> getCircuitBreakersByService(
@PathVariable String serviceName) {
Map<String, CircuitBreakerDTO> circuitBreakers = 
registry.getCircuitBreakersByService(serviceName).entrySet().stream()
.collect(Collectors.toMap(
Map.Entry::getKey,
entry -> toDTO(entry.getValue())
));
return ResponseEntity.ok(circuitBreakers);
}
@GetMapping("/metrics/{circuitBreakerName}")
public ResponseEntity<CircuitBreakerMetricsDTO> getMetrics(
@PathVariable String circuitBreakerName,
@RequestParam(defaultValue = "1h") String duration) {
CircuitBreaker cb = registry.getCircuitBreaker(circuitBreakerName);
if (cb == null) {
return ResponseEntity.notFound().build();
}
CircuitBreakerMetricsDTO metrics = metricsService.getMetrics(cb, duration);
return ResponseEntity.ok(metrics);
}
@GetMapping("/alerts")
public ResponseEntity<List<AlertDTO>> getActiveAlerts() {
List<AlertDTO> alerts = alertService.getActiveAlerts();
return ResponseEntity.ok(alerts);
}
@PostMapping("/alerts/{alertId}/acknowledge")
public ResponseEntity<Void> acknowledgeAlert(@PathVariable String alertId) {
alertService.acknowledgeAlert(alertId);
return ResponseEntity.ok().build();
}
@GetMapping("/summary")
public ResponseEntity<DashboardSummaryDTO> getDashboardSummary() {
Collection<CircuitBreaker> allCircuitBreakers = registry.getAllCircuitBreakers();
long totalCircuitBreakers = allCircuitBreakers.size();
long openCircuitBreakers = allCircuitBreakers.stream()
.filter(cb -> cb.getState() == CircuitBreaker.State.OPEN)
.count();
long halfOpenCircuitBreakers = allCircuitBreakers.stream()
.filter(cb -> cb.getState() == CircuitBreaker.State.HALF_OPEN)
.count();
double overallHealthScore = calculateOverallHealthScore(allCircuitBreakers);
DashboardSummaryDTO summary = new DashboardSummaryDTO(
totalCircuitBreakers,
openCircuitBreakers,
halfOpenCircuitBreakers,
overallHealthScore,
alertService.getActiveAlerts().size()
);
return ResponseEntity.ok(summary);
}
@GetMapping(value = "/events", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public SseEmitter streamCircuitBreakerEvents() {
SseEmitter emitter = new SseEmitter(3600000L); // 1 hour timeout
// Register for real-time events
CircuitBreakerRegistry.CircuitBreakerStateListener listener = 
new CircuitBreakerRegistry.CircuitBreakerStateListener() {
@Override
public void onStateChange(CircuitBreaker circuitBreaker, 
CircuitBreaker.State oldState, 
CircuitBreaker.State newState) {
try {
Map<String, Object> event = new HashMap<>();
event.put("type", "STATE_CHANGE");
event.put("circuitBreaker", circuitBreaker.getName());
event.put("oldState", oldState.name());
event.put("newState", newState.name());
event.put("timestamp", System.currentTimeMillis());
emitter.send(SseEmitter.event()
.name("circuit-breaker-event")
.data(objectMapper.writeValueAsString(event)));
} catch (Exception e) {
emitter.completeWithError(e);
}
}
@Override
public void onMetricsUpdate(CircuitBreaker circuitBreaker) {
try {
Map<String, Object> event = new HashMap<>();
event.put("type", "METRICS_UPDATE");
event.put("circuitBreaker", circuitBreaker.getName());
event.put("metrics", toDTO(circuitBreaker).getMetrics());
event.put("timestamp", System.currentTimeMillis());
emitter.send(SseEmitter.event()
.name("circuit-breaker-event")
.data(objectMapper.writeValueAsString(event)));
} catch (Exception e) {
emitter.completeWithError(e);
}
}
};
registry.addListener(listener);
emitter.onCompletion(() -> registry.removeListener(listener));
emitter.onTimeout(() -> registry.removeListener(listener));
emitter.onError((e) -> registry.removeListener(listener));
return emitter;
}
private CircuitBreakerDTO toDTO(CircuitBreaker circuitBreaker) {
CircuitBreaker.Metrics metrics = circuitBreaker.getMetrics();
CircuitBreakerMetricsDTO metricsDTO = new CircuitBreakerMetricsDTO(
metrics.getTotalRequests(),
metrics.getFailedRequests(),
metrics.getTimeoutRequests(),
metrics.getFailureRate(),
metrics.getLastFailureTimestamp(),
metrics.getLastSuccessTimestamp()
);
return new CircuitBreakerDTO(
circuitBreaker.getName(),
circuitBreaker.getState(),
metricsDTO,
System.currentTimeMillis()
);
}
private double calculateOverallHealthScore(Collection<CircuitBreaker> circuitBreakers) {
if (circuitBreakers.isEmpty()) {
return 100.0;
}
double totalScore = 0.0;
int count = 0;
for (CircuitBreaker cb : circuitBreakers) {
CircuitBreaker.Metrics metrics = cb.getMetrics();
if (metrics.getTotalRequests() > 0) {
double health = 100.0 - metrics.getFailureRate();
totalScore += Math.max(0, health);
count++;
}
}
return count > 0 ? totalScore / count : 100.0;
}
// DTO Classes
public static class CircuitBreakerDTO {
private final String name;
private final CircuitBreaker.State state;
private final CircuitBreakerMetricsDTO metrics;
private final long lastUpdated;
public CircuitBreakerDTO(String name, CircuitBreaker.State state, 
CircuitBreakerMetricsDTO metrics, long lastUpdated) {
this.name = name;
this.state = state;
this.metrics = metrics;
this.lastUpdated = lastUpdated;
}
// Getters
public String getName() { return name; }
public CircuitBreaker.State getState() { return state; }
public CircuitBreakerMetricsDTO getMetrics() { return metrics; }
public long getLastUpdated() { return lastUpdated; }
}
public static class CircuitBreakerMetricsDTO {
private final long totalRequests;
private final long failedRequests;
private final long timeoutRequests;
private final double failureRate;
private final long lastFailureTimestamp;
private final long lastSuccessTimestamp;
public CircuitBreakerMetricsDTO(long totalRequests, long failedRequests, 
long timeoutRequests, double failureRate,
long lastFailureTimestamp, long lastSuccessTimestamp) {
this.totalRequests = totalRequests;
this.failedRequests = failedRequests;
this.timeoutRequests = timeoutRequests;
this.failureRate = failureRate;
this.lastFailureTimestamp = lastFailureTimestamp;
this.lastSuccessTimestamp = lastSuccessTimestamp;
}
// Getters
public long getTotalRequests() { return totalRequests; }
public long getFailedRequests() { return failedRequests; }
public long getTimeoutRequests() { return timeoutRequests; }
public double getFailureRate() { return failureRate; }
public long getLastFailureTimestamp() { return lastFailureTimestamp; }
public long getLastSuccessTimestamp() { return lastSuccessTimestamp; }
}
public static class DashboardSummaryDTO {
private final long totalCircuitBreakers;
private final long openCircuitBreakers;
private final long halfOpenCircuitBreakers;
private final double overallHealthScore;
private final int activeAlerts;
public DashboardSummaryDTO(long totalCircuitBreakers, long openCircuitBreakers,
long halfOpenCircuitBreakers, double overallHealthScore,
int activeAlerts) {
this.totalCircuitBreakers = totalCircuitBreakers;
this.openCircuitBreakers = openCircuitBreakers;
this.halfOpenCircuitBreakers = halfOpenCircuitBreakers;
this.overallHealthScore = overallHealthScore;
this.activeAlerts = activeAlerts;
}
// Getters
public long getTotalCircuitBreakers() { return totalCircuitBreakers; }
public long getOpenCircuitBreakers() { return openCircuitBreakers; }
public long getHalfOpenCircuitBreakers() { return halfOpenCircuitBreakers; }
public double getOverallHealthScore() { return overallHealthScore; }
public int getActiveAlerts() { return activeAlerts; }
}
public static class AlertDTO {
private final String id;
private final String circuitBreakerName;
private final String type;
private final String message;
private final String severity;
private final long timestamp;
private final boolean acknowledged;
public AlertDTO(String id, String circuitBreakerName, String type, 
String message, String severity, long timestamp, boolean acknowledged) {
this.id = id;
this.circuitBreakerName = circuitBreakerName;
this.type = type;
this.message = message;
this.severity = severity;
this.timestamp = timestamp;
this.acknowledged = acknowledged;
}
// Getters
public String getId() { return id; }
public String getCircuitBreakerName() { return circuitBreakerName; }
public String getType() { return type; }
public String getMessage() { return message; }
public String getSeverity() { return severity; }
public long getTimestamp() { return timestamp; }
public boolean isAcknowledged() { return acknowledged; }
}
}

2. Metrics Service

import org.springframework.stereotype.Service;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@Service
public class MetricsService {
private final CircuitBreakerRegistry registry;
private final Map<String, List<CircuitBreakerMetricsSnapshot>> metricsHistory = 
new ConcurrentHashMap<>();
private final ScheduledExecutorService scheduler = 
Executors.newScheduledThreadPool(1);
public MetricsService(CircuitBreakerRegistry registry) {
this.registry = registry;
startMetricsCollection();
}
private void startMetricsCollection() {
// Collect metrics every 10 seconds
scheduler.scheduleAtFixedRate(this::collectMetrics, 0, 10, TimeUnit.SECONDS);
// Clean up old metrics every hour
scheduler.scheduleAtFixedRate(this::cleanupOldMetrics, 1, 1, TimeUnit.HOURS);
}
private void collectMetrics() {
for (CircuitBreaker cb : registry.getAllCircuitBreakers()) {
String cbName = cb.getName();
CircuitBreaker.Metrics currentMetrics = cb.getMetrics();
CircuitBreakerMetricsSnapshot snapshot = new CircuitBreakerMetricsSnapshot(
System.currentTimeMillis(),
currentMetrics.getTotalRequests(),
currentMetrics.getFailedRequests(),
currentMetrics.getTimeoutRequests(),
currentMetrics.getFailureRate(),
cb.getState()
);
metricsHistory.computeIfAbsent(cbName, k -> new ArrayList<>())
.add(snapshot);
}
}
private void cleanupOldMetrics() {
long cutoffTime = System.currentTimeMillis() - (24 * 60 * 60 * 1000); // 24 hours
for (List<CircuitBreakerMetricsSnapshot> snapshots : metricsHistory.values()) {
snapshots.removeIf(snapshot -> snapshot.getTimestamp() < cutoffTime);
}
}
public CircuitBreakerMetricsDTO getMetrics(CircuitBreaker circuitBreaker, String duration) {
String cbName = circuitBreaker.getName();
List<CircuitBreakerMetricsSnapshot> snapshots = metricsHistory.getOrDefault(cbName, 
Collections.emptyList());
long durationMillis = parseDuration(duration);
long cutoffTime = System.currentTimeMillis() - durationMillis;
// Filter snapshots for the requested duration
List<CircuitBreakerMetricsSnapshot> filteredSnapshots = snapshots.stream()
.filter(snapshot -> snapshot.getTimestamp() >= cutoffTime)
.collect(Collectors.toList());
if (filteredSnapshots.isEmpty()) {
// Return current metrics if no history
CircuitBreaker.Metrics currentMetrics = circuitBreaker.getMetrics();
return new CircuitBreakerDashboardController.CircuitBreakerMetricsDTO(
currentMetrics.getTotalRequests(),
currentMetrics.getFailedRequests(),
currentMetrics.getTimeoutRequests(),
currentMetrics.getFailureRate(),
currentMetrics.getLastFailureTimestamp(),
currentMetrics.getLastSuccessTimestamp()
);
}
// Calculate aggregated metrics
long totalRequests = filteredSnapshots.stream()
.mapToLong(CircuitBreakerMetricsSnapshot::getTotalRequests)
.max()
.orElse(0);
long failedRequests = filteredSnapshots.stream()
.mapToLong(CircuitBreakerMetricsSnapshot::getFailedRequests)
.max()
.orElse(0);
long timeoutRequests = filteredSnapshots.stream()
.mapToLong(CircuitBreakerMetricsSnapshot::getTimeoutRequests)
.max()
.orElse(0);
double averageFailureRate = filteredSnapshots.stream()
.mapToDouble(CircuitBreakerMetricsSnapshot::getFailureRate)
.average()
.orElse(0.0);
CircuitBreaker.Metrics currentMetrics = circuitBreaker.getMetrics();
return new CircuitBreakerDashboardController.CircuitBreakerMetricsDTO(
totalRequests,
failedRequests,
timeoutRequests,
averageFailureRate,
currentMetrics.getLastFailureTimestamp(),
currentMetrics.getLastSuccessTimestamp()
);
}
public List<CircuitBreakerMetricsSnapshot> getMetricsHistory(String circuitBreakerName, 
String duration) {
List<CircuitBreakerMetricsSnapshot> snapshots = metricsHistory.getOrDefault(
circuitBreakerName, Collections.emptyList());
long durationMillis = parseDuration(duration);
long cutoffTime = System.currentTimeMillis() - durationMillis;
return snapshots.stream()
.filter(snapshot -> snapshot.getTimestamp() >= cutoffTime)
.collect(Collectors.toList());
}
private long parseDuration(String duration) {
if (duration.endsWith("h")) {
return Long.parseLong(duration.substring(0, duration.length() - 1)) * 60 * 60 * 1000;
} else if (duration.endsWith("m")) {
return Long.parseLong(duration.substring(0, duration.length() - 1)) * 60 * 1000;
} else if (duration.endsWith("s")) {
return Long.parseLong(duration.substring(0, duration.length() - 1)) * 1000;
} else {
return 3600000; // Default 1 hour
}
}
public static class CircuitBreakerMetricsSnapshot {
private final long timestamp;
private final long totalRequests;
private final long failedRequests;
private final long timeoutRequests;
private final double failureRate;
private final CircuitBreaker.State state;
public CircuitBreakerMetricsSnapshot(long timestamp, long totalRequests,
long failedRequests, long timeoutRequests,
double failureRate, CircuitBreaker.State state) {
this.timestamp = timestamp;
this.totalRequests = totalRequests;
this.failedRequests = failedRequests;
this.timeoutRequests = timeoutRequests;
this.failureRate = failureRate;
this.state = state;
}
// Getters
public long getTimestamp() { return timestamp; }
public long getTotalRequests() { return totalRequests; }
public long getFailedRequests() { return failedRequests; }
public long getTimeoutRequests() { return timeoutRequests; }
public double getFailureRate() { return failureRate; }
public CircuitBreaker.State getState() { return state; }
}
}

3. Alert Service

import org.springframework.stereotype.Service;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
@Service
public class AlertService {
private final List<Alert> activeAlerts = new CopyOnWriteArrayList<>();
private final Map<String, AlertRule> alertRules = new ConcurrentHashMap<>();
private final CircuitBreakerRegistry registry;
public AlertService(CircuitBreakerRegistry registry) {
this.registry = registry;
setupDefaultAlertRules();
startAlertMonitoring();
}
private void setupDefaultAlertRules() {
// Rule for circuit breaker opening
alertRules.put("CIRCUIT_BREAKER_OPENED", new AlertRule(
"CIRCUIT_BREAKER_OPENED",
"Circuit Breaker Opened",
"Circuit breaker {circuitBreakerName} changed state to OPEN",
"HIGH",
(circuitBreaker, oldState, newState) -> 
oldState != CircuitBreaker.State.OPEN && newState == CircuitBreaker.State.OPEN
));
// Rule for high failure rate
alertRules.put("HIGH_FAILURE_RATE", new AlertRule(
"HIGH_FAILURE_RATE",
"High Failure Rate",
"Circuit breaker {circuitBreakerName} has high failure rate: {failureRate}%",
"MEDIUM",
(circuitBreaker, oldState, newState) -> {
CircuitBreaker.Metrics metrics = circuitBreaker.getMetrics();
return metrics.getFailureRate() > 30.0; // 30% failure rate threshold
}
));
// Rule for circuit breaker staying open for too long
alertRules.put("CIRCUIT_BREAKER_STUCK_OPEN", new AlertRule(
"CIRCUIT_BREAKER_STUCK_OPEN",
"Circuit Breaker Stuck Open",
"Circuit breaker {circuitBreakerName} has been OPEN for more than 5 minutes",
"HIGH",
(circuitBreaker, oldState, newState) -> {
if (circuitBreaker.getState() == CircuitBreaker.State.OPEN) {
CircuitBreaker.Metrics metrics = circuitBreaker.getMetrics();
long timeSinceLastSuccess = System.currentTimeMillis() - 
metrics.getLastSuccessTimestamp();
return timeSinceLastSuccess > 5 * 60 * 1000; // 5 minutes
}
return false;
}
));
}
private void startAlertMonitoring() {
// Register listener for state changes
registry.addListener(new CircuitBreakerRegistry.CircuitBreakerStateListener() {
@Override
public void onStateChange(CircuitBreaker circuitBreaker, 
CircuitBreaker.State oldState, 
CircuitBreaker.State newState) {
checkAlertRules(circuitBreaker, oldState, newState);
}
@Override
public void onMetricsUpdate(CircuitBreaker circuitBreaker) {
checkAlertRules(circuitBreaker, circuitBreaker.getState(), 
circuitBreaker.getState());
}
});
// Periodic check for all circuit breakers
Timer timer = new Timer(true);
timer.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
for (CircuitBreaker cb : registry.getAllCircuitBreakers()) {
checkAlertRules(cb, cb.getState(), cb.getState());
}
}
}, 0, 30000); // Check every 30 seconds
}
private void checkAlertRules(CircuitBreaker circuitBreaker, 
CircuitBreaker.State oldState, 
CircuitBreaker.State newState) {
for (AlertRule rule : alertRules.values()) {
if (rule.getCondition().test(circuitBreaker, oldState, newState)) {
createAlert(rule, circuitBreaker);
}
}
}
private void createAlert(AlertRule rule, CircuitBreaker circuitBreaker) {
String alertId = UUID.randomUUID().toString();
String message = rule.getMessageTemplate()
.replace("{circuitBreakerName}", circuitBreaker.getName())
.replace("{failureRate}", 
String.format("%.2f", circuitBreaker.getMetrics().getFailureRate()));
// Check if similar alert already exists
boolean alertExists = activeAlerts.stream()
.anyMatch(alert -> alert.getRuleId().equals(rule.getId()) && 
alert.getCircuitBreakerName().equals(circuitBreaker.getName()) && 
!alert.isAcknowledged());
if (!alertExists) {
Alert alert = new Alert(
alertId,
circuitBreaker.getName(),
rule.getId(),
rule.getTitle(),
message,
rule.getSeverity(),
System.currentTimeMillis(),
false
);
activeAlerts.add(alert);
// TODO: Send notification (email, Slack, etc.)
System.out.println("ALERT: " + message);
}
}
public List<CircuitBreakerDashboardController.AlertDTO> getActiveAlerts() {
return activeAlerts.stream()
.filter(alert -> !alert.isAcknowledged())
.map(this::toDTO)
.collect(Collectors.toList());
}
public void acknowledgeAlert(String alertId) {
activeAlerts.stream()
.filter(alert -> alert.getId().equals(alertId))
.findFirst()
.ifPresent(alert -> alert.setAcknowledged(true));
}
public void addAlertRule(AlertRule rule) {
alertRules.put(rule.getId(), rule);
}
public void removeAlertRule(String ruleId) {
alertRules.remove(ruleId);
}
private CircuitBreakerDashboardController.AlertDTO toDTO(Alert alert) {
return new CircuitBreakerDashboardController.AlertDTO(
alert.getId(),
alert.getCircuitBreakerName(),
alert.getRuleId(),
alert.getMessage(),
alert.getSeverity(),
alert.getTimestamp(),
alert.isAcknowledged()
);
}
// Internal classes
private static class Alert {
private final String id;
private final String circuitBreakerName;
private final String ruleId;
private final String title;
private final String message;
private final String severity;
private final long timestamp;
private volatile boolean acknowledged;
public Alert(String id, String circuitBreakerName, String ruleId, 
String title, String message, String severity, 
long timestamp, boolean acknowledged) {
this.id = id;
this.circuitBreakerName = circuitBreakerName;
this.ruleId = ruleId;
this.title = title;
this.message = message;
this.severity = severity;
this.timestamp = timestamp;
this.acknowledged = acknowledged;
}
// Getters and setters
public String getId() { return id; }
public String getCircuitBreakerName() { return circuitBreakerName; }
public String getRuleId() { return ruleId; }
public String getTitle() { return title; }
public String getMessage() { return message; }
public String getSeverity() { return severity; }
public long getTimestamp() { return timestamp; }
public boolean isAcknowledged() { return acknowledged; }
public void setAcknowledged(boolean acknowledged) { this.acknowledged = acknowledged; }
}
public static class AlertRule {
private final String id;
private final String title;
private final String messageTemplate;
private final String severity;
private final AlertCondition condition;
public AlertRule(String id, String title, String messageTemplate, 
String severity, AlertCondition condition) {
this.id = id;
this.title = title;
this.messageTemplate = messageTemplate;
this.severity = severity;
this.condition = condition;
}
// Getters
public String getId() { return id; }
public String getTitle() { return title; }
public String getMessageTemplate() { return messageTemplate; }
public String getSeverity() { return severity; }
public AlertCondition getCondition() { return condition; }
}
@FunctionalInterface
public interface AlertCondition {
boolean test(CircuitBreaker circuitBreaker, 
CircuitBreaker.State oldState, 
CircuitBreaker.State newState);
}
}

Frontend Dashboard (React Example)

1. Main Dashboard Component

import React, { useState, useEffect } from 'react';
import { Card, Row, Col, Statistic, Alert, Table, Tag, Spin } from 'antd';
import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer } from 'recharts';
const CircuitBreakerDashboard = () => {
const [summary, setSummary] = useState(null);
const [circuitBreakers, setCircuitBreakers] = useState([]);
const [alerts, setAlerts] = useState([]);
const [loading, setLoading] = useState(true);
useEffect(() => {
fetchDashboardData();
setupEventSource();
}, []);
const fetchDashboardData = async () => {
try {
const [summaryRes, circuitBreakersRes, alertsRes] = await Promise.all([
fetch('/api/dashboard/summary'),
fetch('/api/dashboard/circuit-breakers'),
fetch('/api/dashboard/alerts')
]);
const summaryData = await summaryRes.json();
const circuitBreakersData = await circuitBreakersRes.json();
const alertsData = await alertsRes.json();
setSummary(summaryData);
setCircuitBreakers(circuitBreakersData);
setAlerts(alertsData);
} catch (error) {
console.error('Failed to fetch dashboard data:', error);
} finally {
setLoading(false);
}
};
const setupEventSource = () => {
const eventSource = new EventSource('/api/dashboard/events');
eventSource.onmessage = (event) => {
const eventData = JSON.parse(event.data);
if (eventData.type === 'STATE_CHANGE' || eventData.type === 'METRICS_UPDATE') {
fetchDashboardData(); // Refresh data
}
};
eventSource.onerror = (error) => {
console.error('EventSource failed:', error);
eventSource.close();
};
return () => eventSource.close();
};
const getStateColor = (state) => {
switch (state) {
case 'CLOSED': return 'green';
case 'OPEN': return 'red';
case 'HALF_OPEN': return 'orange';
default: return 'gray';
}
};
const columns = [
{
title: 'Name',
dataIndex: 'name',
key: 'name',
},
{
title: 'State',
dataIndex: 'state',
key: 'state',
render: (state) => <Tag color={getStateColor(state)}>{state}</Tag>,
},
{
title: 'Failure Rate',
dataIndex: ['metrics', 'failureRate'],
key: 'failureRate',
render: (rate) => `${rate.toFixed(2)}%`,
},
{
title: 'Total Requests',
dataIndex: ['metrics', 'totalRequests'],
key: 'totalRequests',
},
{
title: 'Failed Requests',
dataIndex: ['metrics', 'failedRequests'],
key: 'failedRequests',
},
{
title: 'Last Updated',
dataIndex: 'lastUpdated',
key: 'lastUpdated',
render: (timestamp) => new Date(timestamp).toLocaleString(),
},
];
if (loading) {
return <Spin size="large" />;
}
return (
<div style={{ padding: '24px' }}>
{/* Summary Cards */}
<Row gutter={16} style={{ marginBottom: '24px' }}>
<Col span={6}>
<Card>
<Statistic
title="Total Circuit Breakers"
value={summary?.totalCircuitBreakers}
/>
</Card>
</Col>
<Col span={6}>
<Card>
<Statistic
title="Open Circuit Breakers"
value={summary?.openCircuitBreakers}
valueStyle={{ color: '#cf1322' }}
/>
</Card>
</Col>
<Col span={6}>
<Card>
<Statistic
title="Half-Open Circuit Breakers"
value={summary?.halfOpenCircuitBreakers}
valueStyle={{ color: '#fa8c16' }}
/>
</Card>
</Col>
<Col span={6}>
<Card>
<Statistic
title="Overall Health Score"
value={summary?.overallHealthScore}
precision={2}
suffix="%"
valueStyle={{ color: '#3f8600' }}
/>
</Card>
</Col>
</Row>
{/* Alerts */}
{alerts.length > 0 && (
<div style={{ marginBottom: '24px' }}>
<Alert
message={`${alerts.length} Active Alerts`}
description={
<ul>
{alerts.map(alert => (
<li key={alert.id}>
<strong>{alert.circuitBreakerName}</strong>: {alert.message}
</li>
))}
</ul>
}
type="warning"
showIcon
closable
/>
</div>
)}
{/* Circuit Breakers Table */}
<Card title="Circuit Breakers" style={{ marginBottom: '24px' }}>
<Table
dataSource={circuitBreakers}
columns={columns}
rowKey="name"
pagination={false}
/>
</Card>
{/* Metrics Chart */}
<Card title="Failure Rate Trends">
<ResponsiveContainer width="100%" height={300}>
<LineChart data={circuitBreakers}>
<CartesianGrid strokeDasharray="3 3" />
<XAxis dataKey="name" />
<YAxis />
<Tooltip />
<Legend />
<Line
type="monotone"
dataKey="metrics.failureRate"
stroke="#8884d8"
name="Failure Rate %"
/>
</LineChart>
</ResponsiveContainer>
</Card>
</div>
);
};
export default CircuitBreakerDashboard;

Configuration and Deployment

1. Spring Boot Configuration

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class DashboardConfig {
@Bean
public CircuitBreakerRegistry circuitBreakerRegistry() {
return CircuitBreakerRegistry.getInstance();
}
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurer() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/api/**")
.allowedOrigins("http://localhost:3000") // React app
.allowedMethods("GET", "POST", "PUT", "DELETE")
.allowCredentials(true);
}
};
}
@Bean
public CircuitBreakerRegistry.CircuitBreakerConfig defaultCircuitBreakerConfig() {
CircuitBreakerRegistry.CircuitBreakerConfig config = 
new CircuitBreakerRegistry.CircuitBreakerConfig();
config.setFailureRateThreshold(50.0);
config.setSlowCallRateThreshold(50);
config.setSlowCallDurationThreshold(2000);
config.setWaitDurationInOpenState(60000);
config.setPermittedNumberOfCallsInHalfOpenState(10);
config.setMinimumNumberOfCalls(10);
config.setSlidingWindowSize(100);
return config;
}
}

2. Application Properties

# application.properties
server.port=8080
spring.application.name=circuit-breaker-dashboard
# Logging
logging.level.com.yourcompany.dashboard=DEBUG
# Metrics retention (24 hours)
dashboard.metrics.retention-hours=24
# Alert settings
dashboard.alerts.enabled=true
dashboard.alerts.notification.email.enabled=false
dashboard.alerts.notification.slack.enabled=false
# Security (if needed)
spring.security.oauth2.client.registration.google.client-id=your-client-id
spring.security.oauth2.client.registration.google.client-secret=your-client-secret

Best Practices

  1. Real-time Updates: Use Server-Sent Events for live dashboard updates
  2. Historical Data: Store metrics for trend analysis and debugging
  3. Alerting: Implement multi-level alerting with different severities
  4. Security: Secure dashboard endpoints with authentication/authorization
  5. Scalability: Use distributed caching for large-scale deployments
  6. Customization: Allow custom alert rules and dashboard configurations
  7. Integration: Integrate with existing monitoring systems (Prometheus, Grafana)
  8. Testing: Test circuit breaker behavior under different failure scenarios

This Circuit Breaker Dashboard provides comprehensive monitoring, alerting, and visualization capabilities for managing circuit breakers in distributed systems.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper