/** * The EventConsumerRegistry is used to manage EventConsumer instances. * The EventConsumerRegistry is used by the CircuitBreakerHealthIndicator to show the latest CircuitBreakerEvents events * for each CircuitBreaker instance. * @return a default EventConsumerRegistry {@link io.github.resilience4j.consumer.DefaultEventConsumerRegistry} */ @Bean public EventConsumerRegistry<CircuitBreakerEvent> eventConsumerRegistry() { return new DefaultEventConsumerRegistry<>(); } }
@Override public CircularEventConsumer<T> createEventConsumer(String id, int bufferSize) { CircularEventConsumer<T> eventConsumer = new CircularEventConsumer<>(bufferSize); registry.put(id, eventConsumer); return eventConsumer; }
@Test public void shouldReturnTheSameEventConsumer() { EventConsumerRegistry<CircuitBreakerEvent> registry = new DefaultEventConsumerRegistry<>(); EventConsumer<CircuitBreakerEvent> eventEventConsumer1 = registry.createEventConsumer("testName", 5); EventConsumer<CircuitBreakerEvent> eventEventConsumer2 = registry.getEventConsumer("testName"); assertThat(eventEventConsumer1).isEqualTo(eventEventConsumer2); }
@RequestMapping(value = "events/{circuitBreakerName}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE) @ResponseBody public CircuitBreakerEventsEndpointResponse getEventsFilteredByCircuitBreakerName(@PathVariable("circuitBreakerName") String circuitBreakerName) { return new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry.getEventConsumer(circuitBreakerName).getBufferedEvents() .filter(event -> event.getCircuitBreakerName().equals(circuitBreakerName)) .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList()); }
@Test public void shouldReturnAllEventConsumer() { EventConsumerRegistry<CircuitBreakerEvent> registry = new DefaultEventConsumerRegistry<>(); registry.createEventConsumer("testName1", 5); registry.createEventConsumer("testName2", 2); assertThat(registry.getAllEventConsumer()).hasSize(2); } }
@Test public void shouldCreateAnEventConsumer() { EventConsumerRegistry<CircuitBreakerEvent> registry = new DefaultEventConsumerRegistry<>(); EventConsumer<CircuitBreakerEvent> eventEventConsumer = registry.createEventConsumer("testName", 5); assertThat(eventEventConsumer).isNotNull(); }
@RequestMapping(value = "events", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE) @ResponseBody public CircuitBreakerEventsEndpointResponse getAllCircuitBreakerEvents() { return new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry.getAllEventConsumer() .flatMap(CircularEventConsumer::getBufferedEvents) .sorted(Comparator.comparing(CircuitBreakerEvent::getCreationTime)) .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList()); }
private void subscribeToLimiterEvents(EventConsumerRegistry<RateLimiterEvent> rateLimiterEventsConsumerRegistry, String name, RateLimiterConfigurationProperties.LimiterProperties properties, RateLimiter rateLimiter) { EventConsumer<RateLimiterEvent> eventConsumer = rateLimiterEventsConsumerRegistry .createEventConsumer(name, properties.getEventConsumerBufferSize()); rateLimiter.getEventPublisher().onEvent(eventConsumer); logger.debug("Autoconfigure subscription for Rate Limiter {}", rateLimiter); }
@RequestMapping(value = "events/{rateLimiterName}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE) @ResponseBody public RateLimiterEventsEndpointResponse getEventsFilteredByRateLimiterName(@PathVariable("rateLimiterName") String rateLimiterName) { List<RateLimiterEventDTO> eventsList = eventsConsumerRegistry.getEventConsumer(rateLimiterName).getBufferedEvents() .filter(event -> event.getRateLimiterName().equals(rateLimiterName)) .map(RateLimiterEventDTO::createRateLimiterEventDTO).toJavaList(); return new RateLimiterEventsEndpointResponse(eventsList); }
@RequestMapping(value = "events", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE) @ResponseBody public RateLimiterEventsEndpointResponse getAllRateLimiterEvents() { List<RateLimiterEventDTO> eventsList = eventsConsumerRegistry.getAllEventConsumer() .flatMap(CircularEventConsumer::getBufferedEvents) .sorted(Comparator.comparing(RateLimiterEvent::getCreationTime)) .map(RateLimiterEventDTO::createRateLimiterEventDTO).toJavaList(); return new RateLimiterEventsEndpointResponse(eventsList); }
/** * The EventConsumerRegistry is used to manage EventConsumer instances. * The EventConsumerRegistry is used by the RateLimiterHealthIndicator to show the latest RateLimiterEvents events * for each RateLimiter instance. */ @Bean public EventConsumerRegistry<RateLimiterEvent> rateLimiterEventsConsumerRegistry() { return new DefaultEventConsumerRegistry<>(); }
@Bean public CircuitBreakerRegistry circuitBreakerRegistry(CircuitBreakerConfigurationProperties circuitBreakerProperties, EventConsumerRegistry<CircuitBreakerEvent> eventConsumerRegistry) { CircuitBreakerRegistry circuitBreakerRegistry = CircuitBreakerRegistry.ofDefaults(); circuitBreakerProperties.getBackends().forEach( (name, properties) -> { CircuitBreakerConfig circuitBreakerConfig = circuitBreakerProperties.createCircuitBreakerConfig(name); CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker(name, circuitBreakerConfig); circuitBreaker.getEventPublisher().onEvent(eventConsumerRegistry.createEventConsumer(name, properties.getEventConsumerBufferSize())); } ); return circuitBreakerRegistry; }
@RequestMapping(value = "events/{circuitBreakerName}/{eventType}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE) @ResponseBody public CircuitBreakerEventsEndpointResponse getEventsFilteredByCircuitBreakerNameAndEventType(@PathVariable("circuitBreakerName") String circuitBreakerName, @PathVariable("eventType") String eventType) { return new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry.getEventConsumer(circuitBreakerName).getBufferedEvents() .filter(event -> event.getCircuitBreakerName().equals(circuitBreakerName)) .filter(event -> event.getEventType() == CircuitBreakerEvent.Type.valueOf(eventType.toUpperCase())) .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList()); }
@ReadOperation public CircuitBreakerEventsEndpointResponse getAllCircuitBreakerEvents() { return new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry.getAllEventConsumer() .flatMap(CircularEventConsumer::getBufferedEvents) .sorted(Comparator.comparing(CircuitBreakerEvent::getCreationTime)) .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList()); }
@RequestMapping(value = "events/{rateLimiterName}/{eventType}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE) @ResponseBody public RateLimiterEventsEndpointResponse getEventsFilteredByRateLimiterNameAndEventType(@PathVariable("rateLimiterName") String rateLimiterName, @PathVariable("eventType") String eventType) { RateLimiterEvent.Type targetType = RateLimiterEvent.Type.valueOf(eventType.toUpperCase()); List<RateLimiterEventDTO> eventsList = eventsConsumerRegistry.getEventConsumer(rateLimiterName).getBufferedEvents() .filter(event -> event.getRateLimiterName().equals(rateLimiterName)) .filter(event -> event.getEventType() == targetType) .map(RateLimiterEventDTO::createRateLimiterEventDTO).toJavaList(); return new RateLimiterEventsEndpointResponse(eventsList); }
@ReadOperation public RateLimiterEventsEndpointResponse getAllRateLimiterEvents() { List<RateLimiterEventDTO> eventsList = eventsConsumerRegistry.getAllEventConsumer() .flatMap(CircularEventConsumer::getBufferedEvents) .sorted(Comparator.comparing(RateLimiterEvent::getCreationTime)) .map(RateLimiterEventDTO::createRateLimiterEventDTO).toJavaList(); return new RateLimiterEventsEndpointResponse(eventsList); }
@ReadOperation public RateLimiterEventsEndpointResponse getEventsFilteredByRateLimiterName(@Selector String name) { List<RateLimiterEventDTO> eventsList = eventsConsumerRegistry.getEventConsumer(name).getBufferedEvents() .filter(event -> event.getRateLimiterName().equals(name)) .map(RateLimiterEventDTO::createRateLimiterEventDTO).toJavaList(); return new RateLimiterEventsEndpointResponse(eventsList); }
@ReadOperation public CircuitBreakerEventsEndpointResponse getEventsFilteredByCircuitBreakerName(@Selector String name) { return new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry.getEventConsumer(name).getBufferedEvents() .filter(event -> event.getCircuitBreakerName().equals(name)) .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList()); }
@ReadOperation public RateLimiterEventsEndpointResponse getEventsFilteredByRateLimiterNameAndEventType(@Selector String name, @Selector String eventType) { RateLimiterEvent.Type targetType = RateLimiterEvent.Type.valueOf(eventType.toUpperCase()); List<RateLimiterEventDTO> eventsList = eventsConsumerRegistry.getEventConsumer(name).getBufferedEvents() .filter(event -> event.getRateLimiterName().equals(name)) .filter(event -> event.getEventType() == targetType) .map(RateLimiterEventDTO::createRateLimiterEventDTO).toJavaList(); return new RateLimiterEventsEndpointResponse(eventsList); } }
@ReadOperation public CircuitBreakerEventsEndpointResponse getEventsFilteredByCircuitBreakerNameAndEventType(@Selector String name, @Selector String eventType) { return new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry.getEventConsumer(name).getBufferedEvents() .filter(event -> event.getCircuitBreakerName().equals(name)) .filter(event -> event.getEventType() == CircuitBreakerEvent.Type.valueOf(eventType.toUpperCase())) .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList()); } }