1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package ai.vespa.metricsproxy.core;
import ai.vespa.metricsproxy.core.ConsumersConfig.Consumer;
import ai.vespa.metricsproxy.metric.model.ConsumerId;
import ai.vespa.metricsproxy.metric.model.MetricId;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import static com.yahoo.stream.CustomCollectors.toLinkedMap;
import static java.util.Collections.unmodifiableSet;
import static java.util.stream.Collectors.collectingAndThen;
/**
* Contains metrics consumers and their metrics, and mappings between these.
* All collections are final and immutable.
*
* @author gjoranv
*/
public class MetricsConsumers {
// All metrics for each consumer.
private final Map<ConsumerId, List<ConfiguredMetric>> consumerMetrics;
private final Map<ConsumerId, Map<MetricId, ConfiguredMetric>> configuredMetricByMetricByConsumer;
// All consumers for each metric (more useful than the opposite map).
private final Map<ConfiguredMetric, Set<ConsumerId>> consumersByMetric;
// All consumers for each metric, by metric id
private final Map<MetricId, Map<ConfiguredMetric, Set<ConsumerId>>> consumersByMetricByMetricId;
public MetricsConsumers(ConsumersConfig config) {
consumerMetrics = config.consumer().stream().collect(
toUnmodifiableLinkedMap(consumer -> ConsumerId.toConsumerId(consumer.name()), consumer -> convert(consumer.metric())));
configuredMetricByMetricByConsumer = new HashMap<>();
consumerMetrics.forEach((consumer, configuredList) ->
configuredMetricByMetricByConsumer.put(consumer,
configuredList.stream().collect(Collectors.toMap(ConfiguredMetric::id, Function.identity()))));
consumersByMetric = createConsumersByMetric(consumerMetrics);
consumersByMetricByMetricId = new HashMap<>();
consumersByMetric.forEach((configuredMetric, consumers) -> {
var consumersByMetric = consumersByMetricByMetricId.computeIfAbsent(configuredMetric.id(), id -> new HashMap<>());
var consumerSet = consumersByMetric.computeIfAbsent(configuredMetric, id -> new HashSet<>());
consumerSet.addAll(consumers);
});
}
/**
* @param consumer The consumer
* @return The metrics for the given consumer.
*/
public List<ConfiguredMetric> getMetricDefinitions(ConsumerId consumer) {
return consumerMetrics.get(consumer);
}
public Map<ConfiguredMetric, Set<ConsumerId>> getConsumersByMetric() {
return consumersByMetric;
}
public Map<ConfiguredMetric, Set<ConsumerId>> getConsumersByMetric(MetricId id) {
return consumersByMetricByMetricId.get(id);
}
public Map<MetricId, ConfiguredMetric> getMetricsForConsumer(ConsumerId consumerId) {
return configuredMetricByMetricByConsumer.get(consumerId);
}
public Set<ConsumerId> getAllConsumers() {
return unmodifiableSet(consumerMetrics.keySet());
}
/**
* Helper function to create mapping from metric to consumers.
* TODO: consider reversing the mapping in metrics-consumers.def instead: metric{}.consumer[]
*/
private static Map<ConfiguredMetric, Set<ConsumerId>>
createConsumersByMetric(Map<ConsumerId, List<ConfiguredMetric>> metricsByConsumer) {
Map<ConfiguredMetric, Set<ConsumerId>> consumersByMetric = new LinkedHashMap<>();
metricsByConsumer.forEach(
(consumer, metrics) -> metrics.forEach(
metric -> consumersByMetric.computeIfAbsent(metric, unused -> new HashSet<>())
.add(consumer)));
Map<ConfiguredMetric, Set<ConsumerId>> unmodifiableConsumersByMetric = new LinkedHashMap<>();
consumersByMetric.forEach((configuredMetric, consumerIds) -> unmodifiableConsumersByMetric.put(configuredMetric, Set.copyOf(consumerIds)));
return Collections.unmodifiableMap(unmodifiableConsumersByMetric);
}
public static <T, K, U> Collector<T, ?, Map<K, U>> toUnmodifiableLinkedMap(Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper) {
return collectingAndThen(toLinkedMap(keyMapper, valueMapper), Collections::unmodifiableMap);
}
private List<ConfiguredMetric> convert(List<Consumer.Metric> configMetrics) {
List<ConfiguredMetric> metrics = new ArrayList<>(configMetrics.size());
configMetrics.forEach(m -> metrics.add(new ConfiguredMetric(m)));
return metrics;
}
}
|
