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
|
// Copyright 2018 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.container.jdisc.state;
import com.google.inject.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 com.yahoo.metrics.MetricsPresentationConfig;
import org.json.JSONException;
import org.json.JSONObject;
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 static com.yahoo.container.jdisc.state.StateHandler.getSnapshotPreprocessor;
/**
* This handler outputs metrics in a json-like format. Each individual metric is a json object (packet),
* but there is no outer array or object that wraps the metrics packets. 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 {
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 snapshotPreprocessor;
private final String applicationName;
@Inject
public MetricsPacketsHandler(StateMonitor monitor,
Timer timer,
ComponentRegistry<SnapshotProvider> preprocessors,
MetricsPresentationConfig presentation,
MetricsPacketsHandlerConfig config) {
this.monitor = monitor;
this.timer = timer;
snapshotPreprocessor = getSnapshotPreprocessor(preprocessors, presentation);
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()));
}
}.dispatch(handler);
return null;
}
private byte[] buildMetricOutput() {
try {
String output = getStatusPacket() + getAllMetricsPackets();
return output.getBytes(StandardCharsets.UTF_8);
} catch (JSONException e) {
throw new RuntimeException("Bad JSON construction.", e);
}
}
/**
* Exactly one status packet is added to the response.
*/
private String getStatusPacket() throws JSONException {
JSONObject packet = new JSONObjectWithLegibleException();
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 jsonToString(packet);
}
private String jsonToString(JSONObject jsonObject) throws JSONException {
return jsonObject.toString(4);
}
private String getAllMetricsPackets() throws JSONException {
StringBuilder ret = new StringBuilder();
List<JSONObject> metricsPackets = getPacketsForSnapshot(getSnapshot(), applicationName, timer.currentTimeMillis());
for (JSONObject packet : metricsPackets) {
ret.append(PACKET_SEPARATOR); // For legibility and parsing in unit tests
ret.append(jsonToString(packet));
}
return ret.toString();
}
private MetricSnapshot getSnapshot() {
if (snapshotPreprocessor == null) {
return monitor.snapshot();
} else {
return snapshotPreprocessor.latestSnapshot();
}
}
private List<JSONObject> getPacketsForSnapshot(MetricSnapshot metricSnapshot, String application, long timestamp) throws JSONException {
if (metricSnapshot == null) return Collections.emptyList();
List<JSONObject> packets = new ArrayList<>();
for (Map.Entry<MetricDimensions, MetricSet> snapshotEntry : metricSnapshot) {
MetricDimensions metricDimensions = snapshotEntry.getKey();
MetricSet metricSet = snapshotEntry.getValue();
JSONObjectWithLegibleException packet = new JSONObjectWithLegibleException();
addMetaData(timestamp, application, packet);
addDimensions(metricDimensions, packet);
addMetrics(metricSet, packet);
packets.add(packet);
}
return packets;
}
private void addMetaData(long timestamp, String application, JSONObjectWithLegibleException packet) {
packet.put(APPLICATION_KEY, application);
packet.put(TIMESTAMP_KEY, timestamp);
}
private void addDimensions(MetricDimensions metricDimensions, JSONObjectWithLegibleException packet) throws JSONException {
Iterator<Map.Entry<String, String>> dimensionsIterator = metricDimensions.iterator();
if (dimensionsIterator.hasNext()) {
JSONObject jsonDim = new JSONObjectWithLegibleException();
packet.put(DIMENSIONS_KEY, jsonDim);
for (Map.Entry<String, String> dimensionEntry : metricDimensions) {
jsonDim.put(dimensionEntry.getKey(), dimensionEntry.getValue());
}
}
}
private void addMetrics(MetricSet metricSet, JSONObjectWithLegibleException packet) throws JSONException {
JSONObjectWithLegibleException metrics = new JSONObjectWithLegibleException();
packet.put(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", gauge.getAverage())
.put(name + ".last", gauge.getLast())
.put(name + ".max", 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());
}
}
}
}
|
