com.sap.cloud.cf.monitoring.java.CustomMetricsReporter Maven / Gradle / Ivy

Go to download
package com.sap.cloud.cf.monitoring.java;

import java.util.Collection;
import java.util.List;
import java.util.SortedMap;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.codahale.metrics.Counter;
import com.codahale.metrics.Gauge;
import com.codahale.metrics.Histogram;
import com.codahale.metrics.Meter;
import com.codahale.metrics.MetricFilter;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.ScheduledReporter;
import com.codahale.metrics.Timer;
import com.sap.cloud.cf.monitoring.client.MonitoringClient;
import com.sap.cloud.cf.monitoring.client.configuration.CustomMetricsConfiguration;
import com.sap.cloud.cf.monitoring.client.exceptions.MonitoringClientException;
import com.sap.cloud.cf.monitoring.client.model.Metric;
import com.sap.cloud.cf.monitoring.java.converter.CounterConverter;
import com.sap.cloud.cf.monitoring.java.converter.GaugeConverter;
import com.sap.cloud.cf.monitoring.java.converter.HistogramConverter;
import com.sap.cloud.cf.monitoring.java.converter.MeterConverter;
import com.sap.cloud.cf.monitoring.java.converter.TimerConverter;

public class CustomMetricsReporter extends ScheduledReporter {
    static final int SEND_METRICS_ATTEMPTS = 2;
    private static final Logger LOGGER = LoggerFactory.getLogger(CustomMetricsReporter.class);
    private final MonitoringClient client;
    private final CustomMetricsConfiguration customMetricsConfig;

    private static MetricFilter getFilter(final List whitelistMetrics) {
        if (whitelistMetrics == null || whitelistMetrics.isEmpty()) {
            return MetricFilter.ALL;
        }
        return new MetricFilter() {
            @Override
            public boolean matches(String name, com.codahale.metrics.Metric metric) {
                return whitelistMetrics.contains(name);
            }
        };
    }

    public CustomMetricsReporter(MetricRegistry registry, MonitoringClient client,
                                 CustomMetricsConfiguration customMetricsConfig) {
        super(registry, "custom-metrics-reporter", getFilter(customMetricsConfig.getMetrics()), TimeUnit.SECONDS,
              TimeUnit.MILLISECONDS);
        this.client = client;
        this.customMetricsConfig = customMetricsConfig;
    }

    @Override
    public void report(SortedMap gauges, SortedMap counters,
                       SortedMap histograms, SortedMap meters,
                       SortedMap timers) {
        try {
            List convertedMetrics = convert(gauges, counters, histograms, meters, timers);
            if (convertedMetrics.isEmpty()) {
                LOGGER.debug("No metrics for sending.");
                return;
            }
            sendMetrics(convertedMetrics);
        } catch (Exception e) {
            LOGGER.error("Unable to send metrics.", e);
        }
    }

    private List convert(SortedMap gauges, SortedMap counters,
                                 SortedMap histograms, SortedMap meters,
                                 SortedMap timers) {
        long timestamp = System.currentTimeMillis();
        boolean metricQuantiles = customMetricsConfig.metricQuantiles();

        return Stream.of(new GaugeConverter().convert(gauges, timestamp), 
                  new CounterConverter().convert(counters, timestamp),
                  new HistogramConverter(metricQuantiles).convert(histograms, timestamp), 
                  new MeterConverter(metricQuantiles).convert(meters, timestamp),
                  new TimerConverter(metricQuantiles).convert(timers, timestamp))
        .flatMap(Collection::stream)
        .collect(Collectors.toList());
    }

    private void sendMetrics(List convertedMetrics) {
        for (int i = 0; i < SEND_METRICS_ATTEMPTS; i++) {
            try {
                client.send(convertedMetrics);
                break;
            } catch (MonitoringClientException e) {
                LOGGER.error("Unable to send metrics. Retrying ...", e);
            }
        }
    }
}