org.apache.flink.runtime.rest.messages.job.metrics.AggregatedMetricsResponseBody Java Examples

@Test
public void testDefaultAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(1.0, aggregatedMetric.getMin(), 0.1);
	assertEquals(3.0, aggregatedMetric.getMax(), 0.1);
	assertEquals(2.0, aggregatedMetric.getAvg(), 0.1);
	assertEquals(4.0, aggregatedMetric.getSum(), 0.1);
}
 

@Test
public void testListMetrics() throws Exception {
	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		Collections.emptyMap()
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	List<String> availableMetrics = response.getMetrics().stream()
		.map(AggregatedMetric::getId)
		.sorted()
		.collect(Collectors.toList());

	assertEquals(2, availableMetrics.size());
	assertEquals("abc.metric1", availableMetrics.get(0));
	assertEquals("abc.metric2", availableMetrics.get(1));
}
 

@Test
public void testDefaultAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(1.0, aggregatedMetric.getMin(), 0.1);
	assertEquals(3.0, aggregatedMetric.getMax(), 0.1);
	assertEquals(2.0, aggregatedMetric.getAvg(), 0.1);
	assertEquals(4.0, aggregatedMetric.getSum(), 0.1);
}
 

@Test
public void testListMetrics() throws Exception {
	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		Collections.emptyMap()
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	List<String> availableMetrics = response.getMetrics().stream()
		.map(AggregatedMetric::getId)
		.sorted()
		.collect(Collectors.toList());

	assertEquals(2, availableMetrics.size());
	assertEquals("abc.metric1", availableMetrics.get(0));
	assertEquals("abc.metric2", availableMetrics.get(1));
}
 

@Test
public void testListMetrics() throws Exception {
	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		Collections.emptyMap()
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	List<String> availableMetrics = response.getMetrics().stream()
		.map(AggregatedMetric::getId)
		.sorted()
		.collect(Collectors.toList());

	assertEquals(2, availableMetrics.size());
	assertEquals("abc.metric1", availableMetrics.get(0));
	assertEquals("abc.metric2", availableMetrics.get(1));
}
 

@Test
public void testDefaultAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(1.0, aggregatedMetric.getMin(), 0.1);
	assertEquals(3.0, aggregatedMetric.getMax(), 0.1);
	assertEquals(2.0, aggregatedMetric.getAvg(), 0.1);
	assertEquals(4.0, aggregatedMetric.getSum(), 0.1);
}
 

@Test
public void testMaxAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Collections.singletonList("max"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(3.0, aggregatedMetric.getMax(), 0.1);
	assertNull(aggregatedMetric.getMin());
	assertNull(aggregatedMetric.getSum());
	assertNull(aggregatedMetric.getAvg());
}
 

@Test
public void testMultipleAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Arrays.asList("min", "max", "avg"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(1.0, aggregatedMetric.getMin(), 0.1);
	assertEquals(3.0, aggregatedMetric.getMax(), 0.1);
	assertEquals(2.0, aggregatedMetric.getAvg(), 0.1);
	assertNull(aggregatedMetric.getSum());
}
 

@Test
public void testAvgAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Collections.singletonList("avg"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(2.0, aggregatedMetric.getAvg(), 0.1);
	assertNull(aggregatedMetric.getMin());
	assertNull(aggregatedMetric.getMax());
	assertNull(aggregatedMetric.getSum());
}
 

@Test
public void testSumAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Collections.singletonList("sum"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(4.0, aggregatedMetric.getSum(), 0.1);
	assertNull(aggregatedMetric.getMin());
	assertNull(aggregatedMetric.getMax());
	assertNull(aggregatedMetric.getAvg());
}
 

@Test
public void testMaxAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Collections.singletonList("max"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(3.0, aggregatedMetric.getMax(), 0.1);
	assertNull(aggregatedMetric.getMin());
	assertNull(aggregatedMetric.getSum());
	assertNull(aggregatedMetric.getAvg());
}
 

@Test
public void testMinAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Collections.singletonList("min"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(1.0, aggregatedMetric.getMin(), 0.1);
	assertNull(aggregatedMetric.getMax());
	assertNull(aggregatedMetric.getSum());
	assertNull(aggregatedMetric.getAvg());
}
 

/**
 * Extracts and aggregates all requested metrics from the given metric stores, and maps the result to a JSON string.
 *
 * @param stores available metrics
 * @param requestedMetrics ids of requested metrics
 * @param requestedAggregationsFactories requested aggregations
 * @return JSON string containing the requested metrics
 */
private AggregatedMetricsResponseBody getAggregatedMetricValues(
		Collection<? extends MetricStore.ComponentMetricStore> stores,
		List<String> requestedMetrics,
		MetricAccumulatorFactory requestedAggregationsFactories) {

	Collection<AggregatedMetric> aggregatedMetrics = new ArrayList<>(requestedMetrics.size());
	for (String requestedMetric : requestedMetrics) {
		final Collection<Double> values = new ArrayList<>(stores.size());
		try {
			for (MetricStore.ComponentMetricStore store : stores) {
				String stringValue = store.metrics.get(requestedMetric);
				if (stringValue != null) {
					values.add(Double.valueOf(stringValue));
				}
			}
		} catch (NumberFormatException nfe) {
			log.warn("The metric {} is not numeric and can't be aggregated.", requestedMetric, nfe);
			// metric is not numeric so we can't perform aggregations => ignore it
			continue;
		}
		if (!values.isEmpty()) {

			Iterator<Double> valuesIterator = values.iterator();
			MetricAccumulator acc = requestedAggregationsFactories.get(requestedMetric, valuesIterator.next());
			valuesIterator.forEachRemaining(acc::add);

			aggregatedMetrics.add(acc.get());
		} else {
			return new AggregatedMetricsResponseBody(Collections.emptyList());
		}
	}
	return new AggregatedMetricsResponseBody(aggregatedMetrics);
}
 

@Test
public void testMultipleAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Arrays.asList("min", "max", "avg"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(1.0, aggregatedMetric.getMin(), 0.1);
	assertEquals(3.0, aggregatedMetric.getMax(), 0.1);
	assertEquals(2.0, aggregatedMetric.getAvg(), 0.1);
	assertNull(aggregatedMetric.getSum());
}
 

@Test
public void testAvgAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Collections.singletonList("avg"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(2.0, aggregatedMetric.getAvg(), 0.1);
	assertNull(aggregatedMetric.getMin());
	assertNull(aggregatedMetric.getMax());
	assertNull(aggregatedMetric.getSum());
}
 

@Test
public void testSumAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Collections.singletonList("sum"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(4.0, aggregatedMetric.getSum(), 0.1);
	assertNull(aggregatedMetric.getMin());
	assertNull(aggregatedMetric.getMax());
	assertNull(aggregatedMetric.getAvg());
}
 

@Test
public void testMinAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Collections.singletonList("min"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(1.0, aggregatedMetric.getMin(), 0.1);
	assertNull(aggregatedMetric.getMax());
	assertNull(aggregatedMetric.getSum());
	assertNull(aggregatedMetric.getAvg());
}
 

/**
 * Extracts and aggregates all requested metrics from the given metric stores, and maps the result to a JSON string.
 *
 * @param stores available metrics
 * @param requestedMetrics ids of requested metrics
 * @param requestedAggregationsFactories requested aggregations
 * @return JSON string containing the requested metrics
 */
private AggregatedMetricsResponseBody getAggregatedMetricValues(
		Collection<? extends MetricStore.ComponentMetricStore> stores,
		List<String> requestedMetrics,
		MetricAccumulatorFactory requestedAggregationsFactories) {

	Collection<AggregatedMetric> aggregatedMetrics = new ArrayList<>(requestedMetrics.size());
	for (String requestedMetric : requestedMetrics) {
		final Collection<Double> values = new ArrayList<>(stores.size());
		try {
			for (MetricStore.ComponentMetricStore store : stores) {
				String stringValue = store.metrics.get(requestedMetric);
				if (stringValue != null) {
					values.add(Double.valueOf(stringValue));
				}
			}
		} catch (NumberFormatException nfe) {
			log.warn("The metric {} is not numeric and can't be aggregated.", requestedMetric, nfe);
			// metric is not numeric so we can't perform aggregations => ignore it
			continue;
		}
		if (!values.isEmpty()) {

			Iterator<Double> valuesIterator = values.iterator();
			MetricAccumulator acc = requestedAggregationsFactories.get(requestedMetric, valuesIterator.next());
			valuesIterator.forEachRemaining(acc::add);

			aggregatedMetrics.add(acc.get());
		} else {
			return new AggregatedMetricsResponseBody(Collections.emptyList());
		}
	}
	return new AggregatedMetricsResponseBody(aggregatedMetrics);
}
 

@Test
public void testMultipleAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Arrays.asList("min", "max", "avg"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(1.0, aggregatedMetric.getMin(), 0.1);
	assertEquals(3.0, aggregatedMetric.getMax(), 0.1);
	assertEquals(2.0, aggregatedMetric.getAvg(), 0.1);
	assertNull(aggregatedMetric.getSum());
}
 

@Test
public void testAvgAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Collections.singletonList("avg"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(2.0, aggregatedMetric.getAvg(), 0.1);
	assertNull(aggregatedMetric.getMin());
	assertNull(aggregatedMetric.getMax());
	assertNull(aggregatedMetric.getSum());
}
 

@Test
public void testSumAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Collections.singletonList("sum"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(4.0, aggregatedMetric.getSum(), 0.1);
	assertNull(aggregatedMetric.getMin());
	assertNull(aggregatedMetric.getMax());
	assertNull(aggregatedMetric.getAvg());
}
 

@Test
public void testMaxAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Collections.singletonList("max"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(3.0, aggregatedMetric.getMax(), 0.1);
	assertNull(aggregatedMetric.getMin());
	assertNull(aggregatedMetric.getSum());
	assertNull(aggregatedMetric.getAvg());
}
 

@Test
public void testMinAggregation() throws Exception {
	Map<String, List<String>> queryParams = new HashMap<>(4);
	queryParams.put("get", Collections.singletonList("abc.metric1"));
	queryParams.put("agg", Collections.singletonList("min"));

	HandlerRequest<EmptyRequestBody, P> request = new HandlerRequest<>(
		EmptyRequestBody.getInstance(),
		handler.getMessageHeaders().getUnresolvedMessageParameters(),
		pathParameters,
		queryParams
	);

	AggregatedMetricsResponseBody response = handler.handleRequest(request, MOCK_DISPATCHER_GATEWAY)
		.get();

	Collection<AggregatedMetric> aggregatedMetrics = response.getMetrics();

	assertEquals(1, aggregatedMetrics.size());
	AggregatedMetric aggregatedMetric = aggregatedMetrics.iterator().next();

	assertEquals("abc.metric1", aggregatedMetric.getId());
	assertEquals(1.0, aggregatedMetric.getMin(), 0.1);
	assertNull(aggregatedMetric.getMax());
	assertNull(aggregatedMetric.getSum());
	assertNull(aggregatedMetric.getAvg());
}
 

/**
 * Extracts and aggregates all requested metrics from the given metric stores, and maps the result to a JSON string.
 *
 * @param stores available metrics
 * @param requestedMetrics ids of requested metrics
 * @param requestedAggregationsFactories requested aggregations
 * @return JSON string containing the requested metrics
 */
private AggregatedMetricsResponseBody getAggregatedMetricValues(
		Collection<? extends MetricStore.ComponentMetricStore> stores,
		List<String> requestedMetrics,
		MetricAccumulatorFactory requestedAggregationsFactories) {

	Collection<AggregatedMetric> aggregatedMetrics = new ArrayList<>(requestedMetrics.size());
	for (String requestedMetric : requestedMetrics) {
		final Collection<Double> values = new ArrayList<>(stores.size());
		try {
			for (MetricStore.ComponentMetricStore store : stores) {
				String stringValue = store.metrics.get(requestedMetric);
				if (stringValue != null) {
					values.add(Double.valueOf(stringValue));
				}
			}
		} catch (NumberFormatException nfe) {
			log.warn("The metric {} is not numeric and can't be aggregated.", requestedMetric, nfe);
			// metric is not numeric so we can't perform aggregations => ignore it
			continue;
		}
		if (!values.isEmpty()) {

			Iterator<Double> valuesIterator = values.iterator();
			MetricAccumulator acc = requestedAggregationsFactories.get(requestedMetric, valuesIterator.next());
			valuesIterator.forEachRemaining(acc::add);

			aggregatedMetrics.add(acc.get());
		} else {
			return new AggregatedMetricsResponseBody(Collections.emptyList());
		}
	}
	return new AggregatedMetricsResponseBody(aggregatedMetrics);
}
 

@Override
protected CompletableFuture<AggregatedMetricsResponseBody> handleRequest(@Nonnull HandlerRequest<EmptyRequestBody, P> request, @Nonnull RestfulGateway gateway) throws RestHandlerException {
	return CompletableFuture.supplyAsync(
		() -> {
			try {
				fetcher.update();
				List<String> requestedMetrics = request.getQueryParameter(MetricsFilterParameter.class);
				List<MetricsAggregationParameter.AggregationMode> requestedAggregations = request.getQueryParameter(MetricsAggregationParameter.class);
				MetricStore store = fetcher.getMetricStore();

				Collection<? extends MetricStore.ComponentMetricStore> stores = getStores(store, request);

				if (requestedMetrics.isEmpty()) {
					Collection<String> list = getAvailableMetrics(stores);
					return new AggregatedMetricsResponseBody(
						list.stream()
							.map(AggregatedMetric::new)
							.collect(Collectors.toList())
					);
				}

				DoubleAccumulator.DoubleMinimumFactory minimumFactory = null;
				DoubleAccumulator.DoubleMaximumFactory maximumFactory = null;
				DoubleAccumulator.DoubleAverageFactory averageFactory = null;
				DoubleAccumulator.DoubleSumFactory sumFactory = null;
				// by default we return all aggregations
				if (requestedAggregations.isEmpty()) {
					minimumFactory = DoubleAccumulator.DoubleMinimumFactory.get();
					maximumFactory = DoubleAccumulator.DoubleMaximumFactory.get();
					averageFactory = DoubleAccumulator.DoubleAverageFactory.get();
					sumFactory = DoubleAccumulator.DoubleSumFactory.get();
				} else {
					for (MetricsAggregationParameter.AggregationMode aggregation : requestedAggregations) {
						switch (aggregation) {
							case MIN:
								minimumFactory = DoubleAccumulator.DoubleMinimumFactory.get();
								break;
							case MAX:
								maximumFactory = DoubleAccumulator.DoubleMaximumFactory.get();
								break;
							case AVG:
								averageFactory = DoubleAccumulator.DoubleAverageFactory.get();
								break;
							case SUM:
								sumFactory = DoubleAccumulator.DoubleSumFactory.get();
								break;
							default:
								log.warn("Unsupported aggregation specified: {}", aggregation);
						}
					}
				}
				MetricAccumulatorFactory metricAccumulatorFactory = new MetricAccumulatorFactory(minimumFactory, maximumFactory, averageFactory, sumFactory);

				return getAggregatedMetricValues(stores, requestedMetrics, metricAccumulatorFactory);
			} catch (Exception e) {
				log.warn("Could not retrieve metrics.", e);
				throw new CompletionException(new RestHandlerException("Could not retrieve metrics.", HttpResponseStatus.INTERNAL_SERVER_ERROR));
			}
		},
		executor);
}
 

@Override
protected CompletableFuture<AggregatedMetricsResponseBody> handleRequest(@Nonnull HandlerRequest<EmptyRequestBody, P> request, @Nonnull RestfulGateway gateway) throws RestHandlerException {
	return CompletableFuture.supplyAsync(
		() -> {
			try {
				fetcher.update();
				List<String> requestedMetrics = request.getQueryParameter(MetricsFilterParameter.class);
				List<MetricsAggregationParameter.AggregationMode> requestedAggregations = request.getQueryParameter(MetricsAggregationParameter.class);
				MetricStore store = fetcher.getMetricStore();

				Collection<? extends MetricStore.ComponentMetricStore> stores = getStores(store, request);

				if (requestedMetrics.isEmpty()) {
					Collection<String> list = getAvailableMetrics(stores);
					return new AggregatedMetricsResponseBody(
						list.stream()
							.map(AggregatedMetric::new)
							.collect(Collectors.toList())
					);
				}

				DoubleAccumulator.DoubleMinimumFactory minimumFactory = null;
				DoubleAccumulator.DoubleMaximumFactory maximumFactory = null;
				DoubleAccumulator.DoubleAverageFactory averageFactory = null;
				DoubleAccumulator.DoubleSumFactory sumFactory = null;
				// by default we return all aggregations
				if (requestedAggregations.isEmpty()) {
					minimumFactory = DoubleAccumulator.DoubleMinimumFactory.get();
					maximumFactory = DoubleAccumulator.DoubleMaximumFactory.get();
					averageFactory = DoubleAccumulator.DoubleAverageFactory.get();
					sumFactory = DoubleAccumulator.DoubleSumFactory.get();
				} else {
					for (MetricsAggregationParameter.AggregationMode aggregation : requestedAggregations) {
						switch (aggregation) {
							case MIN:
								minimumFactory = DoubleAccumulator.DoubleMinimumFactory.get();
								break;
							case MAX:
								maximumFactory = DoubleAccumulator.DoubleMaximumFactory.get();
								break;
							case AVG:
								averageFactory = DoubleAccumulator.DoubleAverageFactory.get();
								break;
							case SUM:
								sumFactory = DoubleAccumulator.DoubleSumFactory.get();
								break;
							default:
								log.warn("Unsupported aggregation specified: {}", aggregation);
						}
					}
				}
				MetricAccumulatorFactory metricAccumulatorFactory = new MetricAccumulatorFactory(minimumFactory, maximumFactory, averageFactory, sumFactory);

				return getAggregatedMetricValues(stores, requestedMetrics, metricAccumulatorFactory);
			} catch (Exception e) {
				log.warn("Could not retrieve metrics.", e);
				throw new CompletionException(new RestHandlerException("Could not retrieve metrics.", HttpResponseStatus.INTERNAL_SERVER_ERROR));
			}
		},
		executor);
}
 

@Override
protected CompletableFuture<AggregatedMetricsResponseBody> handleRequest(@Nonnull HandlerRequest<EmptyRequestBody, P> request, @Nonnull RestfulGateway gateway) throws RestHandlerException {
	return CompletableFuture.supplyAsync(
		() -> {
			try {
				fetcher.update();
				List<String> requestedMetrics = request.getQueryParameter(MetricsFilterParameter.class);
				List<MetricsAggregationParameter.AggregationMode> requestedAggregations = request.getQueryParameter(MetricsAggregationParameter.class);
				MetricStore store = fetcher.getMetricStore();

				Collection<? extends MetricStore.ComponentMetricStore> stores = getStores(store, request);

				if (requestedMetrics.isEmpty()) {
					Collection<String> list = getAvailableMetrics(stores);
					return new AggregatedMetricsResponseBody(
						list.stream()
							.map(AggregatedMetric::new)
							.collect(Collectors.toList())
					);
				}

				DoubleAccumulator.DoubleMinimumFactory minimumFactory = null;
				DoubleAccumulator.DoubleMaximumFactory maximumFactory = null;
				DoubleAccumulator.DoubleAverageFactory averageFactory = null;
				DoubleAccumulator.DoubleSumFactory sumFactory = null;
				// by default we return all aggregations
				if (requestedAggregations.isEmpty()) {
					minimumFactory = DoubleAccumulator.DoubleMinimumFactory.get();
					maximumFactory = DoubleAccumulator.DoubleMaximumFactory.get();
					averageFactory = DoubleAccumulator.DoubleAverageFactory.get();
					sumFactory = DoubleAccumulator.DoubleSumFactory.get();
				} else {
					for (MetricsAggregationParameter.AggregationMode aggregation : requestedAggregations) {
						switch (aggregation) {
							case MIN:
								minimumFactory = DoubleAccumulator.DoubleMinimumFactory.get();
								break;
							case MAX:
								maximumFactory = DoubleAccumulator.DoubleMaximumFactory.get();
								break;
							case AVG:
								averageFactory = DoubleAccumulator.DoubleAverageFactory.get();
								break;
							case SUM:
								sumFactory = DoubleAccumulator.DoubleSumFactory.get();
								break;
							default:
								log.warn("Unsupported aggregation specified: {}", aggregation);
						}
					}
				}
				MetricAccumulatorFactory metricAccumulatorFactory = new MetricAccumulatorFactory(minimumFactory, maximumFactory, averageFactory, sumFactory);

				return getAggregatedMetricValues(stores, requestedMetrics, metricAccumulatorFactory);
			} catch (Exception e) {
				log.warn("Could not retrieve metrics.", e);
				throw new CompletionException(new RestHandlerException("Could not retrieve metrics.", HttpResponseStatus.INTERNAL_SERVER_ERROR));
			}
		},
		executor);
}