com.netflix.hystrix.HystrixEventType Java Examples

@Override
public void markEvent(HystrixEventType eventType, HystrixCommandKey key) {
  String keyName = key.name();
  AtomicBoolean flag = circuitFlag.computeIfAbsent(keyName, k -> new AtomicBoolean());
  switch (eventType) {
    case SHORT_CIRCUITED:
      if (flag.compareAndSet(false, true)) {
        eventBus.post(new CircutBreakerEvent(key, Type.OPEN));
      }
      break;

    case SUCCESS:
      if (flag.compareAndSet(true, false)) {
        eventBus.post(new CircutBreakerEvent(key, Type.CLOSE));
      }
      break;

    default:
      break;
  }
}
 

private String getExecutionEventsString() {
    List<HystrixEventType> executionEvents = getExecutionEvents();
    if (executionEvents == null) {
        executionEvents = Collections.emptyList();
    }
    StringBuilder message = new StringBuilder("[");
    for (HystrixEventType executionEvent : executionEvents) {
        message.append(HystrixEventType.class.getSimpleName()).append("#").append(executionEvent.name())
            .append(",");
    }
    for (SofaAsyncHystrixEvent event : events) {
        message.append(SofaAsyncHystrixEvent.class.getSimpleName()).append("#").append(event.name()).append(",");
    }
    if (message.length() > 1) {
        message.deleteCharAt(message.length() - 1);
    }
    return message.append("]").toString();
}
 

@Test
public void test() {
    HystrixRequestContext context = HystrixRequestContext.initializeContext();
    try {
        assertEquals(null, new CommandWithFallbackViaNetwork(1).execute());

        HystrixInvokableInfo<?> command1 = HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().toArray(new HystrixInvokableInfo<?>[2])[0];
        assertEquals("GetValueCommand", command1.getCommandKey().name());
        assertTrue(command1.getExecutionEvents().contains(HystrixEventType.FAILURE));

        HystrixInvokableInfo<?> command2 = HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().toArray(new HystrixInvokableInfo<?>[2])[1];
        assertEquals("GetValueFallbackCommand", command2.getCommandKey().name());
        assertTrue(command2.getExecutionEvents().contains(HystrixEventType.FAILURE));
    } finally {
        context.shutdown();
    }
}
 

private static void commandWithFallbackViaNetworkTest() {
    HystrixRequestContext context = HystrixRequestContext.initializeContext();
    try {
         log.info(new CommandWithFallbackViaNetwork(1).execute());

        HystrixInvokableInfo<?> command1 = HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().toArray(new HystrixInvokableInfo<?>[2])[0];
        log.info(command1.getCommandKey().name());
        log.info(""+command1.getExecutionEvents().contains(HystrixEventType.FAILURE));

        HystrixInvokableInfo<?> command2 = HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().toArray(new HystrixInvokableInfo<?>[2])[1];
        log.info(command2.getCommandKey().name());
        log.info(""+command2.getExecutionEvents().contains(HystrixEventType.FAILURE));
    } finally {
        context.shutdown();
    }
}
 

@Override
public void markCommandExecution(HystrixCommandKey key, ExecutionIsolationStrategy isolationStrategy, int duration, List<HystrixEventType> eventsDuringExecution) {
    if (MultiConfigId.hasMultiSourceId(key)) {
        strategies.get(MultiConfigId.readFrom(key))
                  .markCommandExecution(MultiConfigId.decode(key), isolationStrategy, duration, eventsDuringExecution);
    }
    else {
        underlying()
                .map(notifier -> {
                    notifier.markCommandExecution(key, isolationStrategy, duration, eventsDuringExecution);
                    return null;
                })
                .orElseGet(() -> {
                    super.markCommandExecution(key, isolationStrategy, duration, eventsDuringExecution);
                    return null;
                });
    }
}
 

@Override
public void markEvent(HystrixEventType eventType, HystrixCommandKey key) {
    if (MultiConfigId.hasMultiSourceId(key)) {
        strategies.get(MultiConfigId.readFrom(key))
                  .markEvent(eventType, MultiConfigId.decode(key));
    }
    else {
        underlying()
                .map(notifier -> {
                    notifier.markEvent(eventType, key);
                    return null;
                })
                .orElseGet(() -> {
                    super.markEvent(eventType, key);
                    return null;
                });
    }
}
 

private void logEvent(HystrixEventType eventType) {
	switch (eventType) {
		case FAILURE:
			log.info(String.format("Aborted command execution: cause=%s astrixBean=%s hystrixCommandKey=%s", eventType, beanKey, hystrixCommandKey.name()));
			break;
		case SEMAPHORE_REJECTED:
			logSemaphoreRejectedRequest(eventType);
			break;
		case THREAD_POOL_REJECTED:
			logThreadPoolRejectedRequest(eventType);
			break;
		case TIMEOUT:
			logTimeoutRequest(eventType);
			break;
		case SHORT_CIRCUITED:
			log.info(String.format("Aborted command execution: cause=%s astrixBean=%s hystrixCommandKey=%s", eventType, beanKey, hystrixCommandKey.name()));
			break;
		default:
			// Do nothing
	}
}
 

private void initMetrics(Ping ping) throws InterruptedException {
	// Black hystrix magic here :(
	try {
		ping.ping("foo");
	} catch (Exception e) {
	}
	HystrixFaultToleranceFactory faultTolerance = (HystrixFaultToleranceFactory) AstrixApplicationContext.class.cast(this.context).getInstance(BeanFaultToleranceFactorySpi.class);
	HystrixCommandKey key = faultTolerance.getCommandKey(AstrixBeanKey.create(Ping.class));
	
	HystrixCommandMetrics.getInstance(key).getCumulativeCount(HystrixEventType.SUCCESS);
}
 

private void initMetrics(Ping ping, AstrixContext context) {
	try {
		ping.ping("foo");
	} catch (Exception e) {
	}
	HystrixFaultToleranceFactory faultTolerance = (HystrixFaultToleranceFactory) AstrixApplicationContext.class.cast(context).getInstance(BeanFaultToleranceFactorySpi.class);
	HystrixCommandKey key = faultTolerance.getCommandKey(AstrixBeanKey.create(Ping.class));
	HystrixCommandMetrics.getInstance(key).getCumulativeCount(HystrixEventType.SUCCESS);
}
 

private void initMetrics(Ping ping) throws InterruptedException {
	// Black hystrix magic here :(
	try {
		ping.ping();
	} catch (Exception e) {
	}
	HystrixFaultToleranceFactory faultTolerance = (HystrixFaultToleranceFactory) AstrixApplicationContext.class.cast(this.context).getInstance(BeanFaultToleranceFactorySpi.class);
	HystrixCommandKey key = faultTolerance.getCommandKey(AstrixBeanKey.create(Ping.class));
	
	HystrixCommandMetrics.getInstance(key).getCumulativeCount(HystrixEventType.SUCCESS);
}
 

private void initMetrics(Ping ping) throws InterruptedException {
	// Black hystrix magic here :(
	try {
		ping.ping("foo");
	} catch (Exception e) {
	}
	HystrixFaultToleranceFactory faultTolerance = (HystrixFaultToleranceFactory) AstrixApplicationContext.class.cast(this.context).getInstance(BeanFaultToleranceFactorySpi.class);
	HystrixCommandKey key = faultTolerance.getCommandKey(AstrixBeanKey.create(Ping.class));
	
	HystrixCommandMetrics.getInstance(key).getCumulativeCount(HystrixEventType.SUCCESS);
}
 

private Consumer<HystrixEventType> createNonBeanInvocationCommandLogger(HystrixCommandKey key) {
	return eventType -> {
		switch (eventType) {
		case FAILURE:
		case SEMAPHORE_REJECTED:
		case THREAD_POOL_REJECTED:
		case TIMEOUT:
		case SHORT_CIRCUITED:
			log.info(String.format("Aborted command execution: cause=%s astrixBean=null hystrixCommandKey=%s", eventType, key.name()));
			break;
		default:
			// Do nothing
		}
	};
}
 

@Override
public void markCommandExecution(HystrixCommandKey key, 
								 ExecutionIsolationStrategy isolationStrategy, 
								 int duration,
								 List<HystrixEventType> eventsDuringExecution) {
	strategymapping.getHystrixStrategies(key)
				   .getHystrixEventNotifier()
				   .markCommandExecution(key, isolationStrategy, duration, eventsDuringExecution);
}
 

@Test
public void testMarkEvent() {
  Mockito.when(commandKey.name()).thenReturn("Consumer.springmvc.springmvcHello.sayHi");
  new Expectations(HystrixCommandMetrics.class) {
    {
      HystrixCommandMetrics.getInstance(commandKey);
      result = null;
    }
  };
  circutBreakerEventNotifier.markEvent(HystrixEventType.SHORT_CIRCUITED, commandKey);
  Assert.assertEquals(1, taskList.size());
  circutBreakerEventNotifier.markEvent(HystrixEventType.SUCCESS, commandKey);
  Assert.assertEquals(2, taskList.size());
}
 

private void logEvent(HystrixEventType eventType, HystrixCommandKey commandKey) {
	getBeanInvocationLogger(commandKey).orElse(createNonBeanInvocationCommandLogger(commandKey))
									   .accept(eventType);
}
 

@Override
public void markEvent(HystrixEventType eventType, HystrixCommandKey key) {
	logEvent(eventType, key);
}
 

private Optional<Consumer<HystrixEventType>> getBeanInvocationLogger(HystrixCommandKey commandKey) {
	return beanMapping.getBeanKey(commandKey)
					  .map(beanKey -> getOrCreateBeanInvocationLogger(commandKey, beanKey));
}
 

private Consumer<HystrixEventType> getOrCreateBeanInvocationLogger(HystrixCommandKey commandKey,
		AstrixBeanKey<?> beanKey) {
	return beanLoggerByBeanKey.computeIfAbsent(beanKey, k -> createLogger(commandKey, beanKey));
}
 

@Override
public void accept(HystrixEventType t) {
	logEvent(t);
}
 

@Override
public void markEvent(HystrixEventType eventType, HystrixCommandKey key) {
	strategymapping.getHystrixStrategies(key)
	   			   .getHystrixEventNotifier()
	   			   .markEvent(eventType, key);
}
 

private void logTimeoutRequest(HystrixEventType eventType) {
	log.info(String.format("Aborted command execution: cause=%s astrixBean=%s hystrixCommandKey=%s TIMEOUT=%s [ms]", 
			eventType, beanKey, hystrixCommandKey.name(), 
			beanConfiguration.get(AstrixBeanSettings.TIMEOUT).get()));
}
 

private void logThreadPoolRejectedRequest(HystrixEventType eventType) {
	log.info(String.format("Aborted command execution: cause=%s astrixBean=%s hystrixCommandKey=%s CORE_SIZE=%s QUEUE_SIZE_REJECTION_THRESHOLD=%s", 
			eventType, beanKey, hystrixCommandKey.name(), 
			beanConfiguration.get(AstrixBeanSettings.CORE_SIZE).get(), beanConfiguration.get(AstrixBeanSettings.QUEUE_SIZE_REJECTION_THRESHOLD).get()));
}
 

private void logSemaphoreRejectedRequest(HystrixEventType eventType) {
	log.info(String.format("Aborted command execution: cause=%s astrixBean=%s hystrixCommandKey=%s MAX_CONCURRENT_REQUESTS=%s", 
			eventType, beanKey, hystrixCommandKey.name(), 
			beanConfiguration.get(AstrixBeanSettings.MAX_CONCURRENT_REQUESTS).get()));
}
 

public void markFailure() {
    concurrentExecutionCount.decrementAndGet();
    HystrixThreadEventStream.getInstance()
            .executionDone(ExecutionResult.from(HystrixEventType.FAILURE), commandKey, threadPoolKey);
    circuitBreaker.markNonSuccess();
}
 

public void markSuccessfully() {
    concurrentExecutionCount.decrementAndGet();
    HystrixThreadEventStream.getInstance()
            .executionDone(ExecutionResult.from(HystrixEventType.SUCCESS), commandKey, threadPoolKey);
    circuitBreaker.markSuccess();
}