@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); }
@Override public CircularEventConsumer<T> createEventConsumer(String id, int bufferSize) { CircularEventConsumer<T> eventConsumer = new CircularEventConsumer<>(bufferSize); registry.put(id, eventConsumer); return eventConsumer; }
@Test public void shouldNotBufferEvents() { // Given CircuitBreaker circuitBreaker = CircuitBreaker.ofDefaults("testName"); CircularEventConsumer<CircuitBreakerEvent> ringBuffer = new CircularEventConsumer<>(2); assertThat(ringBuffer.getBufferedEvents()).isEmpty(); circuitBreaker.onError(0, new RuntimeException("Bla")); circuitBreaker.onError(0, new RuntimeException("Bla")); circuitBreaker.onError(0, new RuntimeException("Bla")); //Subscription is too late circuitBreaker.getEventPublisher().onEvent(ringBuffer); //Then CircuitBreaker.Metrics metrics = circuitBreaker.getMetrics(); assertThat(metrics.getNumberOfBufferedCalls()).isEqualTo(3); assertThat(metrics.getNumberOfFailedCalls()).isEqualTo(3); //Should store 0 events, because Subscription was too late assertThat(ringBuffer.getBufferedEvents()).hasSize(0); } }
@Test public void shouldBufferErrorEvents() { // Given // tag::shouldBufferEvents[] CircuitBreaker circuitBreaker = CircuitBreaker.ofDefaults("testName"); CircularEventConsumer<CircuitBreakerEvent> ringBuffer = new CircularEventConsumer<>(2); circuitBreaker.getEventPublisher().onEvent(ringBuffer); // end::shouldBufferEvents[] assertThat(ringBuffer.getBufferedEvents()).isEmpty(); //When circuitBreaker.onError(0, new RuntimeException("Bla")); circuitBreaker.onError(0, new RuntimeException("Bla")); circuitBreaker.onError(0, new RuntimeException("Bla")); //Then CircuitBreaker.Metrics metrics = circuitBreaker.getMetrics(); assertThat(metrics.getNumberOfBufferedCalls()).isEqualTo(3); assertThat(metrics.getNumberOfFailedCalls()).isEqualTo(3); //Should only store 2 events, because capacity is 2 assertThat(ringBuffer.getBufferedEvents()).hasSize(2); //ringBuffer.getBufferedEvents().forEach(event -> LOG.info(event.toString())); }
@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()); }
.build(); CircuitBreaker circuitBreaker = CircuitBreaker.of("testName", circuitBreakerConfig); CircularEventConsumer<CircuitBreakerEvent> ringBuffer = new CircularEventConsumer<>(10); circuitBreaker.getEventPublisher().onEvent(ringBuffer); assertThat(ringBuffer.getBufferedEvents()).isEmpty(); assertThat(ringBuffer.getBufferedEvents()).hasSize(7); assertThat(ringBuffer.getBufferedEvents()).extracting("eventType") .containsExactly(Type.SUCCESS, Type.ERROR, Type.IGNORED_ERROR, Type.ERROR, Type.STATE_TRANSITION, Type.STATE_TRANSITION, Type.RESET);
@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); }
@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 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()); } }
BulkheadEventsEndpointResponse response = new BulkheadEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(bulkheadName) .getBufferedEvents() .map(BulkheadEventDTO::createEventDTO).toJavaList()); d.success(response); BulkheadEventsEndpointResponse response = new BulkheadEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(bulkheadName) .getBufferedEvents() .filter(event -> event.getEventType() == BulkheadEvent.Type.valueOf(eventType.toUpperCase())) .map(BulkheadEventDTO::createEventDTO).toJavaList());
Promise.<RetryEventsEndpointResponse>async(d -> { List<RetryEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(retryName) .getBufferedEvents() .sorted(Comparator.comparing(RetryEvent::getCreationTime)) .map(RetryEventDTO::createRetryEventDTO).toJavaList(); Promise.<RetryEventsEndpointResponse>async(d -> { List<RetryEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(retryName) .getBufferedEvents() .sorted(Comparator.comparing(RetryEvent::getCreationTime)) .filter(event -> event.getEventType() == RetryEvent.Type.valueOf(eventType.toUpperCase()))
Promise.<RateLimiterEventsEndpointResponse>async(d -> { List<RateLimiterEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(rateLimiterName) .getBufferedEvents() .sorted(Comparator.comparing(RateLimiterEvent::getCreationTime)) .map(RateLimiterEventDTO::createRateLimiterEventDTO).toJavaList(); Promise.<RateLimiterEventsEndpointResponse>async(d -> { List<RateLimiterEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(rateLimiterName) .getBufferedEvents() .sorted(Comparator.comparing(RateLimiterEvent::getCreationTime)) .filter(event -> event.getEventType() == RateLimiterEvent.Type.valueOf(eventType.toUpperCase()))
CircuitBreakerEventsEndpointResponse response = new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(circuitBreakerName) .getBufferedEvents() .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList()); d.success(response); CircuitBreakerEventsEndpointResponse response = new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(circuitBreakerName) .getBufferedEvents() .filter(event -> event.getEventType() == CircuitBreakerEvent.Type.valueOf(eventType.toUpperCase())) .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList());
Promise.<RetryEventsEndpointResponse>async(d -> { List<RetryEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(retryName) .getBufferedEvents() .sorted(Comparator.comparing(RetryEvent::getCreationTime)) .map(RetryEventDTO::createRetryEventDTO).toJavaList(); Promise.<RetryEventsEndpointResponse>async(d -> { List<RetryEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(retryName) .getBufferedEvents() .sorted(Comparator.comparing(RetryEvent::getCreationTime)) .filter(event -> event.getEventType() == RetryEvent.Type.valueOf(eventType.toUpperCase()))
Promise.<RateLimiterEventsEndpointResponse>async(d -> { List<RateLimiterEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(rateLimiterName) .getBufferedEvents() .sorted(Comparator.comparing(RateLimiterEvent::getCreationTime)) .map(RateLimiterEventDTO::createRateLimiterEventDTO).toJavaList(); Promise.<RateLimiterEventsEndpointResponse>async(d -> { List<RateLimiterEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(rateLimiterName) .getBufferedEvents() .sorted(Comparator.comparing(RateLimiterEvent::getCreationTime)) .filter(event -> event.getEventType() == RateLimiterEvent.Type.valueOf(eventType.toUpperCase()))
CircuitBreakerEventsEndpointResponse response = new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(circuitBreakerName) .getBufferedEvents() .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList()); d.success(response); CircuitBreakerEventsEndpointResponse response = new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(circuitBreakerName) .getBufferedEvents() .filter(event -> event.getEventType() == CircuitBreakerEvent.Type.valueOf(eventType.toUpperCase())) .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList());
BulkheadEventsEndpointResponse response = new BulkheadEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(bulkheadName) .getBufferedEvents() .map(BulkheadEventDTO::createEventDTO).toJavaList()); d.success(response); BulkheadEventsEndpointResponse response = new BulkheadEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(bulkheadName) .getBufferedEvents() .filter(event -> event.getEventType() == BulkheadEvent.Type.valueOf(eventType.toUpperCase())) .map(BulkheadEventDTO::createEventDTO).toJavaList());