private void assertMetricsContainsTag(String tagKey, String tagValue) { List<Meter.Id> meterIds = null; try { meterIds = this.meterRegistry.getMeters().stream() .map(Meter::getId) .collect(Collectors.toList()); Collection<Timer> timers = this.meterRegistry.get(REQUEST_METRICS_NAME).timers(); System.err.println("Looking for gateway.requests: tag: " + tagKey + ", value: "+ tagValue); timers.forEach(timer -> System.err.println(timer.getId()+timer.getClass().getSimpleName())); long count = getCount(tagKey, tagValue); assertThat(count).isEqualTo(1); } catch (MeterNotFoundException e) { System.err.println("\n\n\nError finding gatway.requests meter: tag: " + tagKey + ", value: "+ tagValue); System.err.println("\n\n\nMeter ids prior to search: "+meterIds + "\n\n\n and after:"); this.meterRegistry.forEachMeter(meter -> System.err.println(meter.getId() + meter.getClass().getSimpleName())); // try again? long count = getCount(tagKey, tagValue); if (count != 1) { throw e; } } }
/** * Returns a newly-created immutable {@link Map} which contains all values of {@link Meter}s in the * specified {@link MeterRegistry}. The format of the key string is: * <ul> * <li>{@code <name>#<statistic>{tagName=tagValue,...}}</li> * <li>e.g. {@code "armeria.server.activeRequests#value{method=greet}"}</li> * <li>e.g. {@code "someSubsystem.someValue#sumOfSquares"} (no tags)</li> * </ul> * Note: It is not recommended to use this method for the purposes other than testing. */ public static Map<String, Double> measureAll(MeterRegistry registry) { requireNonNull(registry, "registry"); final ImmutableMap.Builder<String, Double> builder = ImmutableMap.builder(); registry.forEachMeter(meter -> Streams.stream(meter.measure()).forEach(measurement -> { final String fullName = measurementName(meter.getId(), measurement); final double value = measurement.getValue(); builder.put(fullName, value); })); return builder.build(); }
private void mergeMeasurements(Map<Statistic, Double> samples, Meter meter) { meter.measure().forEach((measurement) -> samples.merge(measurement.getStatistic(), measurement.getValue(), mergeFunction(measurement.getStatistic()))); }
List<MetricDatum> metricData() { Batch batch = new Batch(); return getMeters().stream().flatMap(m -> m.match( batch::gaugeData, batch::counterData, batch::timerData, batch::summaryData, batch::longTaskTimerData, batch::timeGaugeData, batch::functionCounterData, batch::functionTimerData, batch::metricData) ).collect(toList()); }
@Override protected void publish() { for (Meter meter : getMeters()) { meter.use( this::announceGauge, this::announceCounter, this::announceTimer, this::announceSummary, this::announceLongTaskTimer, this::announceTimeGauge, this::announceFunctionCounter, this::announceFunctionTimer, this::announceMeter); } }
Optional<String> writeMeter(Meter meter) { return Optional.of(writeDocument(meter, builder -> { for (Measurement measurement : meter.measure()) { builder.append(",\"").append(measurement.getStatistic().getTagValueRepresentation()).append("\":\"").append(measurement.getValue()).append("\""); } })); }
@Override protected void publish() { String insightsEndpoint = config.uri() + "/v1/accounts/" + config.accountId() + "/events"; // New Relic's Insights API limits us to 1000 events per call for (List<Meter> batch : MeterPartition.partition(this, Math.min(config.batchSize(), 1000))) { sendEvents(insightsEndpoint, batch.stream().flatMap(meter -> meter.match( this::writeGauge, this::writeCounter, this::writeTimer, this::writeSummary, this::writeLongTaskTimer, this::writeTimeGauge, this::writeFunctionCounter, this::writeFunctionTimer, this::writeMeter))); } }
@Test public void metricsActivatedHasDistinctNameTags() { Schedulers.newParallel("A", 3); Schedulers.newParallel("B", 2); assertThat(simpleMeterRegistry.getMeters() .stream() .map(m -> m.getId().getTag("name")) .distinct()) .containsOnly( "parallel(3,\"A\")-0", "parallel(3,\"A\")-1", "parallel(3,\"A\")-2", "parallel(2,\"B\")-0", "parallel(2,\"B\")-1" ); }
private Stream<TimeSeries> createMeter(Batch batch, Meter m) { return stream(m.measure().spliterator(), false) .map(ms -> batch.createTimeSeries(m, ms.getValue(), ms.getStatistic().getTagValueRepresentation())); }
protected void publish() { for (List<Meter> batch : MeterPartition.partition(this, config.batchSize())) { Stream<String> stream = batch.stream().flatMap(m -> m.match( this::writeMeter, this::writeMeter,
@Test public void decorateTwiceWithSameSchedulerInstance() { Scheduler instance = Schedulers.newElastic("TWICE", 1); ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); Schedulers.decorateExecutorService(instance, service); Schedulers.decorateExecutorService(instance, service); assertThat(simpleMeterRegistry.getMeters() .stream() .map(m -> m.getId().getTag("name")) .distinct()) .containsOnly( "elastic(\"TWICE\")-0", "elastic(\"TWICE\")-1" ); }
private void announceMeter(Meter meter) { for (Measurement measurement : meter.measure()) { announce(meter, measurement.getValue(), measurement.getStatistic().toString().toLowerCase()); } }
@Override protected void publish() { final long timestamp = clock.wallTime(); AggregateMetricSender metricSender = new AggregateMetricSender(this.config.source(), this.dataPointReceiverFactory, this.eventReceiverFactory, new StaticAuthToken(this.config.accessToken()), this.onSendErrorHandlerCollection); for (List<Meter> batch : MeterPartition.partition(this, config.batchSize())) { try (AggregateMetricSender.Session session = metricSender.createSession()) { batch.stream() .map(meter -> meter.match( this::addGauge, this::addCounter, this::addTimer, this::addDistributionSummary, this::addLongTaskTimer, this::addTimeGauge, this::addFunctionCounter, this::addFunctionTimer, this::addMeter)) .flatMap(builders -> builders.map(builder -> builder.setTimestamp(timestamp).build())) .forEach(session::setDatapoint); logger.debug("successfully sent {} metrics to SignalFx.", batch.size()); } catch (Throwable e) { logger.warn("failed to send metrics", e); } } }
@Test public void disablingMetricsRemovesSchedulerMeters() { Schedulers.newParallel("A", 1); Schedulers.newParallel("A", 1); Schedulers.newParallel("A", 1); Metrics.globalRegistry.counter("foo", "tagged", "bar"); Schedulers.disableMetrics(); assertThat(simpleMeterRegistry.getMeters() .stream() .map(m -> m.getId().getName()) .distinct()) .containsExactly("foo"); } }
private Stream<SignalFxProtocolBuffers.DataPoint.Builder> addMeter(Meter meter) { return stream(meter.measure().spliterator(), false).flatMap(measurement -> { String statSuffix = NamingConvention.camelCase.tagKey(measurement.getStatistic().toString()); switch (measurement.getStatistic()) { case TOTAL: case TOTAL_TIME: case COUNT: case DURATION: return Stream.of(addDatapoint(meter, COUNTER, statSuffix, measurement.getValue())); case MAX: case VALUE: case UNKNOWN: case ACTIVE_TASKS: return Stream.of(addDatapoint(meter, GAUGE, statSuffix, measurement.getValue())); } return Stream.empty(); }); }
.withJsonContent( batch.stream() .map(meter -> meter.match( this::writeGauge, this::writeCounter,