Java HystrixCommandMetrics类代码示例

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
@Test
public void checkNotifierIsCalledOnceForEveryCommand() {
    mocks.forEach(m -> doAnswer(a -> {
        HystrixCommandMetrics metrics = a.getArgument(0);
        log.info("initialize for command {} and group {}", metrics.getCommandKey().name(), metrics.getCommandGroup().name());
                return null;
            }).when(m).initialize(any())
    );

    HystrixPlugins.getInstance().registerMetricsPublisher(notifier);

    for (int i = 0; i < 3; i++) {
        Command.from(GROUP_KEY, COMMAND_1, SUCCESS, 50).observe();
    }

    for (int i = 0; i < 5; i++) {
        Command.from(GROUP_KEY, COMMAND_2, FAILURE, 60).observe();
    }

    mocks.forEach(m -> {
        verify(m, times(1)).initialize(withKey(COMMAND_1));
        verify(m, times(1)).initialize(withKey(COMMAND_2));
        verifyNoMoreInteractions(m);
    });
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
public void printHystrixCommandMetrics() {
    for (HystrixCommandMetrics metrics : HystrixCommandMetrics.getInstances()) {
        boolean isCircuitOpen = HystrixCircuitBreaker.Factory.getInstance(metrics.getCommandKey()).isOpen();

        LOGGER.info("group:{}, commandKey:{}, CircuitOpen:{}, Mean:{}, 95%:{}, 99%:{}, 99.5%:{}, {}",
                metrics.getCommandGroup().name(),
                metrics.getCommandKey().name(),
                isCircuitOpen,
                metrics.getExecutionTimeMean(),
                metrics.getExecutionTimePercentile(95.0),
                metrics.getExecutionTimePercentile(99.5),
                metrics.getExecutionTimePercentile(99.5),
                metrics.getHealthCounts()
        );
    }
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
@RequestMapping(value = "/commands", method = RequestMethod.GET)
public List<HystrixCommandStats> commandStats() {
    return HystrixCommandMetrics.getInstances().stream().map((m) -> {
        final HystrixCommandStats s = new HystrixCommandStats();
        s.currentConcurrentExecutionCount = m.getCurrentConcurrentExecutionCount();
        s.commandGroup = m.getCommandGroup().name();
        s.commandKey = m.getCommandKey().name();
        s.executionTimeMean = m.getExecutionTimeMean();
        s.errorCount = m.getHealthCounts().getErrorCount();
        s.totalCount = m.getHealthCounts().getTotalRequests();
        s.errorPercentage = m.getHealthCounts().getErrorPercentage();
        s.totalTimeMean = m.getTotalTimeMean();

        return s;
    }).collect(Collectors.toList());
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
public HystrixKafkaCircuitBreaker(final String brokerId) {
    commandKey = HystrixCommandKey.Factory.asKey(brokerId);
    commandProperties = HystrixPropertiesFactory.getCommandProperties(commandKey, null);
    threadPoolKey = HystrixThreadPoolKey.Factory.asKey(brokerId);
    hystrixCommandMetrics = HystrixCommandMetrics.getInstance(
            commandKey,
            HYSTRIX_CMD_GROUP_KEY,
            threadPoolKey,
            commandProperties);
    circuitBreaker = HystrixCircuitBreaker.Factory.getInstance(
            commandKey,
            HYSTRIX_CMD_GROUP_KEY,
            commandProperties,
            hystrixCommandMetrics);
    concurrentExecutionCount = new AtomicInteger();
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
private static void printMetrics() {
   for (HystrixCommandMetrics metric : HystrixCommandMetrics.getInstances()) {
      System.out.println("Metric: " + metric.getCommandGroup().name());
      System.out.println("execution-time-mean: " + metric.getExecutionTimeMean());
      System.out.println("total-time-mean: " + metric.getTotalTimeMean());
      System.out.println("total-count: " + metric.getHealthCounts().getTotalRequests());
      System.out.println("error-count: " + metric.getHealthCounts().getErrorCount());
      System.out.println("error-%: " + metric.getHealthCounts().getErrorPercentage());
   }

   for (HystrixThreadPoolMetrics metrics : HystrixThreadPoolMetrics.getInstances()) {
      System.out.println("cumulative-count-threads-executed: " + metrics.getCumulativeCountThreadsExecuted());
      System.out.println("current-active-count: " + metrics.getCurrentActiveCount());
      System.out.println("current-completed-task-count: " + metrics.getCurrentCompletedTaskCount());
      System.out.println("current-core-pool-size: " + metrics.getCurrentCorePoolSize());
      System.out.println("current-largest-pool-size: " + metrics.getCurrentLargestPoolSize());
      System.out.println("current-max-pool-size: " + metrics.getCurrentMaximumPoolSize());
      System.out.println("current-pool-size: " + metrics.getCurrentPoolSize());
      System.out.println("current-queue-size: " + metrics.getCurrentQueueSize());
      System.out.println("current-task-count: " + metrics.getCurrentTaskCount());
      System.out.println("rolling-count-threads-executed: " + metrics.getRollingCountThreadsExecuted());
      System.out.println("rolling-max-active-threads: " + metrics.getRollingMaxActiveThreads());
   }
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
private void printMetrics() {
    HystrixCommandMetrics metrics =
            HystrixCommandMetrics.
                    getInstance(HystrixCommandKey.Factory.asKey(this.getClass().getSimpleName()));
    StringBuilder m = new StringBuilder();
    if (metrics != null) {
        HystrixCommandMetrics.HealthCounts health = metrics.getHealthCounts();
        m.append("Requests: ").append(health.getTotalRequests()).append(" ");
        m.append("Errors: ").append(health.getErrorCount()).append(" (").
                append(health.getErrorPercentage()).append("%)   ");
        m.append("Mean: ").append(metrics.getExecutionTimePercentile(50)).append(" ");
        m.append("75th: ").append(metrics.getExecutionTimePercentile(75)).append(" ");
        m.append("90th: ").append(metrics.getExecutionTimePercentile(90)).append(" ");
        m.append("99th: ").append(metrics.getExecutionTimePercentile(99)).append(" ");
    }
    System.out.println(m);
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
@Override
protected void doHealthCheck(Builder builder) throws Exception {
	List<String> openCircuitBreakers = new ArrayList<>();

	// Collect all open circuit breakers from Hystrix
	for (HystrixCommandMetrics metrics : HystrixCommandMetrics.getInstances()) {
		HystrixCircuitBreaker circuitBreaker = HystrixCircuitBreaker.Factory
				.getInstance(metrics.getCommandKey());
		if (circuitBreaker != null && circuitBreaker.isOpen()) {
			openCircuitBreakers.add(metrics.getCommandGroup().name() + "::"
					+ metrics.getCommandKey().name());
		}
	}

	// If there is at least one open circuit report OUT_OF_SERVICE adding the command
	// group
	// and key name
	if (!openCircuitBreakers.isEmpty()) {
		builder.status(CIRCUIT_OPEN).withDetail("openCircuitBreakers",
				openCircuitBreakers);
	}
	else {
		builder.up();
	}
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
@Override
public String call() {
  List<TpsAndLatencyData> tpsAndLatencyData = HystrixCommandMetrics.getInstances()
      .stream()
      .map(instance -> new TpsAndLatencyData(instance.getRollingCount(HystrixEventType.SUCCESS),
          instance.getRollingCount(HystrixEventType.FAILURE), instance.getExecutionTimeMean(),
          instance.getProperties().metricsRollingStatisticalWindowInMilliseconds().get()))
      .collect(Collectors.toList());
  return calculateTpsAndLatency(tpsAndLatencyData);
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
@Override
public void initialize(HystrixCommandMetrics metrics) {
    if (filter.test(metrics)) {
        final HystrixCommandKey key = metrics.getCommandKey();
        log.debug("Aggregate stream for command {}", key.name());
        streams.onNext(HystrixCommandCompletionStream.getInstance(key).observe());
    }
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
@ManagedAttribute
public int getHystrixTotalTimeMean() {
    HystrixCommandMetrics metrics = HystrixCommandMetrics.getInstance(commandKey);
    if (metrics != null) {
        return metrics.getTotalTimeMean();
    }
    return 0;
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
@ManagedAttribute
public int getHystrixExecutionTimeMean() {
    HystrixCommandMetrics metrics = HystrixCommandMetrics.getInstance(commandKey);
    if (metrics != null) {
        return metrics.getExecutionTimeMean();
    }
    return 0;
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
@ManagedAttribute
public int getHystrixCurrentConcurrentExecutionCount() {
    HystrixCommandMetrics metrics = HystrixCommandMetrics.getInstance(commandKey);
    if (metrics != null) {
        return metrics.getCurrentConcurrentExecutionCount();
    }
    return 0;
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
@ManagedAttribute
public long getHystrixTotalRequests() {
    HystrixCommandMetrics metrics = HystrixCommandMetrics.getInstance(commandKey);
    if (metrics != null) {
        return metrics.getHealthCounts().getTotalRequests();
    }
    return 0;
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
@ManagedAttribute
public long getHystrixErrorCount() {
    HystrixCommandMetrics metrics = HystrixCommandMetrics.getInstance(commandKey);
    if (metrics != null) {
        return metrics.getHealthCounts().getErrorCount();
    }
    return 0;
}
 

import com.netflix.hystrix.HystrixCommandMetrics; //导入依赖的package包/类
@ManagedAttribute
public int getHystrixErrorPercentage() {
    HystrixCommandMetrics metrics = HystrixCommandMetrics.getInstance(commandKey);
    if (metrics != null) {
        return metrics.getHealthCounts().getErrorPercentage();
    }
    return 0;
}