public static GaugeMetricValue makeGaugeVal(Time startTime, List<DataPoint> points) { TimeRange range = TimeRange.between(startTime, startTime.plus(Time.inNanos(1))); GaugeMetricValueBuilder builder = new GaugeMetricValueBuilder(range); for (DataPoint point : points) { builder.addPoint(point.getValue()); } return builder.build(); }
public GaugeMetricValueBuilder addPoint(IDataPoint pt) { addPoint(pt.getValue()); return this; }
static Command createMetricCommand (ResourceKey resKey, TimeRange range, String key, PointType pt, Collection<? extends IDataPoint> points) { if (ListUtil.size(points) <= 0) { return null; } ResourceMetricKey metricKey = ResourceMetricKey.valueOf(resKey, MetricKey.valueOf(key)); switch (pt) { case COUNTER: { CounterMetricValueBuilder valueBuilder = new CounterMetricValueBuilder(range); CounterMetricValue mValue = (CounterMetricValue)aggregateValue(points, valueBuilder); return new UpdateMetricCommand(metricKey, mValue); } case GAUGE: { GaugeMetricValueBuilder valueBuilder=new GaugeMetricValueBuilder(range); GaugeMetricValue gValue = (GaugeMetricValue)aggregateValue(points, valueBuilder); return new UpdateMetricDistributionCommand(metricKey, gValue); } default: throw new IllegalStateException("createMetricCommand(" + metricKey + ")[" + range + "] unhandled point type: " + pt); } }
public static List<GaugeMetricValue> makeGaugeVals(DataPoint... points) { List<GaugeMetricValue> res = new ArrayList<GaugeMetricValue>(); for (DataPoint pt : points) { Time ptTime = pt.getTimeStamp(); TimeRange range = TimeRange.between(ptTime, ptTime.plus(Time.inNanos(1))); res.add(new GaugeMetricValueBuilder(range).addPoint(pt.getValue()).build()); } return res; }
/** * Make a list of {@link GaugeMetricValue}s. Each returned value will * be for a range from [now+vals[k]..now+vals[k]+1ns), with a value of vals[k] */ public static List<GaugeMetricValue> makeGaugeVals(Time now, long... vals) { if (vals.length % 2 != 0) { throw new IllegalArgumentException("vals.length % 2 must be == 0"); } List<GaugeMetricValue> res = new ArrayList<GaugeMetricValue>(); for (int i=0; i<vals.length; i+=2) { Time time = now.plus(Time.inSeconds((int)vals[i])); TimeRange range = TimeRange.between(time, time.plus(Time.inNanos(1))); res.add(new GaugeMetricValueBuilder(range).addPoint(vals[i+1]).build()); } return res; }
private int getSizeOfDummyGaugePage(int numElementsPerPage) { GaugeMetricPage dummyGaugePage = new GaugeMetricPage(Granularity.inNanos(5), Time.inNanos(100), numElementsPerPage); for (int i=0; i < numElementsPerPage; i++) { GaugeMetricValueBuilder b = new GaugeMetricValueBuilder(new TimeRange(100 + i * 5, 105 + i * 5)); for (int j=0; j<100; j++) { b.addPoint(j); } dummyGaugePage.setValue(b.build()); } return ObjectSizer.REFLECTION_SIZE.sizeof(dummyGaugePage); }
public List<GaugeMetricValue> calculateSortedSegmentedPoints(List<IDataPoint> sortedPoints, Granularity gran) { List<GaugeMetricValue> metrics = new ArrayList<GaugeMetricValue>(); IDataPoint startPt = sortedPoints.get(0); long startTime = startPt.getTimeStamp().alignDownToGranularity(gran).getNanos(); long endTime = startTime + gran.getNanos(); GaugeMetricValueBuilder builder = new GaugeMetricValueBuilder(TimeRange.nanoTimeRange(startTime, endTime)); for (IDataPoint pt : sortedPoints) { long ptNanos = pt.getTimeStamp().getNanos(); if (ptNanos >= endTime) { GaugeMetricValue metric = builder.build(); metrics.add(metric); while (ptNanos >= endTime) { startTime = endTime; endTime += gran.getNanos(); } builder = new GaugeMetricValueBuilder(TimeRange.nanoTimeRange(startTime, endTime)); } builder.addPoint(pt.getValue()); } metrics.add(builder.build()); return metrics; }
@Override @InsightEndPoint public void executeCommand(UpdateMetricCommand command) { ResourceMetricKey key = command.getKey(); MetricData adapter = dataRepo.createOrGetMetricData(key); if (adapter instanceof CounterMetricDataAdapter) { CounterMetricDataAdapter mData = (CounterMetricDataAdapter) adapter; mData.increment(command.getCounterMetricValue()); return; } if (adapter instanceof GaugeMetricDataAdapter) { GaugeMetricDataAdapter mData = (GaugeMetricDataAdapter) adapter; IDataPoint point = command.getPoint(); GaugeMetricValue value = new GaugeMetricValueBuilder(command.getTimeRange()).addPoint(point.getValue()).build(); mData.addValues(singletonList(value)); return; } } }
@Override @InsightEndPoint public void executeCommand(AddPointCommand command) { ResourceMetricKey key = command.getResourceMetricKey(); GaugeMetricDataAdapter mData = (GaugeMetricDataAdapter) dataRepo.createOrGetMetricData(key); DataPoint point = command.getPoint(); Time rangeStart = point.getTimeStamp(); Time rangeEnd = rangeStart.plus(Time.inMillis((int)point.getValue())); if (rangeEnd.equals(rangeStart)) { // In case of something executing in no time, our range is still 1 ns rangeEnd = rangeEnd.plus(Time.inNanos(1)); } TimeRange pointRange = TimeRange.between(rangeStart, rangeEnd); GaugeMetricValue value = new GaugeMetricValueBuilder(pointRange).addPoint(point.getValue()).build(); mData.addValues(singletonList(value)); } }