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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.container.jdisc.state;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.yahoo.component.annotation.Inject;
import com.yahoo.collections.Tuple2;
import com.yahoo.component.provider.ComponentRegistry;
import com.yahoo.jdisc.Request;
import com.yahoo.jdisc.Response;
import com.yahoo.jdisc.Timer;
import com.yahoo.jdisc.handler.AbstractRequestHandler;
import com.yahoo.jdisc.handler.ContentChannel;
import com.yahoo.jdisc.handler.ResponseDispatch;
import com.yahoo.jdisc.handler.ResponseHandler;
import com.yahoo.jdisc.http.HttpHeaders;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import static com.yahoo.container.jdisc.state.JsonUtil.sanitizeDouble;
import static com.yahoo.container.jdisc.state.StateHandler.getSnapshotProviderOrThrow;
/**
* This handler outputs metrics in a json-like format, consisting of a series of metrics packets.
* Each packet is a json object but there is no outer array or object that wraps the packets.
* To reduce the amount of output, a packet contains all metrics that share the same set of dimensions.
*
* This handler is not set up by default, but can be added to the applications's services configuration.
*
* This handler is protocol agnostic, so it cannot discriminate between e.g. http request
* methods (get/head/post etc.).
*
* Based on {@link StateHandler}.
*
* @author gjoranv
*/
public class MetricsPacketsHandler extends AbstractRequestHandler {
private static final ObjectMapper jsonMapper = new ObjectMapper();
static final String APPLICATION_KEY = "application";
static final String TIMESTAMP_KEY = "timestamp";
static final String STATUS_CODE_KEY = "status_code";
static final String STATUS_MSG_KEY = "status_msg";
static final String METRICS_KEY = "metrics";
static final String DIMENSIONS_KEY = "dimensions";
static final String PACKET_SEPARATOR = "\n\n";
private final StateMonitor monitor;
private final Timer timer;
private final SnapshotProvider snapshotProvider;
private final String applicationName;
@Inject
public MetricsPacketsHandler(StateMonitor monitor,
Timer timer,
ComponentRegistry<SnapshotProvider> snapshotProviders,
MetricsPacketsHandlerConfig config) {
this.monitor = monitor;
this.timer = timer;
snapshotProvider = getSnapshotProviderOrThrow(snapshotProviders);
applicationName = config.application();
}
@Override
public ContentChannel handleRequest(Request request, ResponseHandler handler) {
new ResponseDispatch() {
@Override
protected Response newResponse() {
Response response = new Response(Response.Status.OK);
response.headers().add(HttpHeaders.Names.CONTENT_TYPE, "application/json");
return response;
}
@Override
protected Iterable<ByteBuffer> responseContent() {
return Collections.singleton(ByteBuffer.wrap(buildMetricOutput(request.getUri().getQuery())));
}
}.dispatch(handler);
return null;
}
private byte[] buildMetricOutput(String query) {
try {
if (query != null && query.equals("array-formatted")) {
return getMetricsArray();
}
String output = jsonToString(getStatusPacket()) + getAllMetricsPackets() + "\n";
return output.getBytes(StandardCharsets.UTF_8);
} catch (JsonProcessingException e) {
throw new RuntimeException("Bad JSON construction.", e);
}
}
private byte[] getMetricsArray() throws JsonProcessingException {
ObjectNode root = jsonMapper.createObjectNode();
ArrayNode jsonArray = jsonMapper.createArrayNode();
jsonArray.add(getStatusPacket());
getPacketsForSnapshot(getSnapshot(), applicationName, timer.currentTimeMillis())
.forEach(jsonArray::add);
MetricGatherer.getAdditionalMetrics().forEach(jsonArray::add);
root.set("metrics", jsonArray);
return jsonToString(root)
.getBytes(StandardCharsets.UTF_8);
}
/**
* Exactly one status packet is added to the response.
*/
private JsonNode getStatusPacket() {
ObjectNode packet = jsonMapper.createObjectNode();
packet.put(APPLICATION_KEY, applicationName);
StateMonitor.Status status = monitor.status();
packet.put(STATUS_CODE_KEY, status.ordinal());
packet.put(STATUS_MSG_KEY, status.name());
return packet;
}
private static String jsonToString(JsonNode jsonObject) throws JsonProcessingException {
return jsonMapper.writerWithDefaultPrettyPrinter()
.writeValueAsString(jsonObject);
}
private String getAllMetricsPackets() throws JsonProcessingException {
StringBuilder ret = new StringBuilder();
List<JsonNode> metricsPackets = getPacketsForSnapshot(getSnapshot(), applicationName, timer.currentTimeMillis());
for (JsonNode packet : metricsPackets) {
ret.append(PACKET_SEPARATOR); // For legibility and parsing in unit tests
ret.append(jsonToString(packet));
}
return ret.toString();
}
private MetricSnapshot getSnapshot() {
return snapshotProvider.latestSnapshot();
}
private List<JsonNode> getPacketsForSnapshot(MetricSnapshot metricSnapshot, String application, long timestamp) {
if (metricSnapshot == null) return Collections.emptyList();
List<JsonNode> packets = new ArrayList<>();
for (Map.Entry<MetricDimensions, MetricSet> snapshotEntry : metricSnapshot) {
MetricDimensions metricDimensions = snapshotEntry.getKey();
MetricSet metricSet = snapshotEntry.getValue();
ObjectNode packet = jsonMapper.createObjectNode();
addMetaData(timestamp, application, packet);
addDimensions(metricDimensions, packet);
addMetrics(metricSet, packet);
packets.add(packet);
}
return packets;
}
private void addMetaData(long timestamp, String application, ObjectNode packet) {
packet.put(APPLICATION_KEY, application);
packet.put(TIMESTAMP_KEY, TimeUnit.MILLISECONDS.toSeconds(timestamp));
}
private void addDimensions(MetricDimensions metricDimensions, ObjectNode packet) {
if (metricDimensions == null) return;
Iterator<Map.Entry<String, String>> dimensionsIterator = metricDimensions.iterator();
if (dimensionsIterator.hasNext()) {
ObjectNode jsonDim = jsonMapper.createObjectNode();
packet.set(DIMENSIONS_KEY, jsonDim);
for (Map.Entry<String, String> dimensionEntry : metricDimensions) {
jsonDim.put(dimensionEntry.getKey(), dimensionEntry.getValue());
}
}
}
private void addMetrics(MetricSet metricSet, ObjectNode packet) {
ObjectNode metrics = jsonMapper.createObjectNode();
packet.set(METRICS_KEY, metrics);
for (Map.Entry<String, MetricValue> metric : metricSet) {
String name = metric.getKey();
MetricValue value = metric.getValue();
if (value instanceof CountMetric) {
metrics.put(name + ".count", ((CountMetric) value).getCount());
} else if (value instanceof GaugeMetric) {
GaugeMetric gauge = (GaugeMetric) value;
metrics.put(name + ".average", sanitizeDouble(gauge.getAverage()))
.put(name + ".last", sanitizeDouble(gauge.getLast()))
.put(name + ".max", sanitizeDouble(gauge.getMax()));
if (gauge.getPercentiles().isPresent()) {
for (Tuple2<String, Double> prefixAndValue : gauge.getPercentiles().get()) {
metrics.put(name + "." + prefixAndValue.first + "percentile", prefixAndValue.second.doubleValue());
}
}
} else {
throw new UnsupportedOperationException("Unknown metric class: " + value.getClass().getName());
}
}
}
}
|
