com.signalfx.metrics.flush.AggregateMetricSender Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of signalfx-java Show documentation
Bare minimum core library needed to sending metrics to SignalFx from Java clients
The newest version!
package com.signalfx.metrics.flush;

import static java.util.Objects.requireNonNull;

import com.signalfx.metrics.SignalFxMetricsException;
import com.signalfx.metrics.auth.AuthToken;
import com.signalfx.metrics.auth.NoAuthTokenException;
import com.signalfx.metrics.connection.DataPointReceiver;
import com.signalfx.metrics.connection.DataPointReceiverFactory;
import com.signalfx.metrics.connection.EventReceiver;
import com.signalfx.metrics.connection.EventReceiverFactory;
import com.signalfx.metrics.errorhandler.MetricErrorImpl;
import com.signalfx.metrics.errorhandler.MetricErrorType;
import com.signalfx.metrics.errorhandler.OnSendErrorHandler;
import com.signalfx.metrics.protobuf.SignalFxProtocolBuffers;
import java.io.Closeable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;


/**
 * The primary java class to send metrics.  To use this class, create a session, add points to
 * the session, and when you are done, close the session.  For example:
 *
 *  * {@code
 *  AggregateMetricSender sender;
 *     try (AggregateMetricSender.Session i = mf.createSession()) {
 *         i.incrementCounter("testcounter2", 1);
 *         i.setDatapoint(
 *            SignalFxProtocolBuffers.DataPoint.newBuilder()
 *              .setMetric("curtime")
 *              .setValue(
 *                SignalFxProtocolBuffers.Datum.newBuilder()
 *                .setIntValue(System.currentTimeMillis()))
 *              .addDimensions(
 *                SignalFxProtocolBuffers.Dimension.newBuilder()
 *                  .setKey("source")
 *                  .setValue("java"))
 *              .build());
 *     }
 * }
 * 
 */
public class AggregateMetricSender {
    private final String defaultSourceName;
    private final Set registeredMetricPairs;
    private final DataPointReceiverFactory dataPointReceiverFactory;
    private final EventReceiverFactory eventReceiverFactory;
    private final AuthToken authToken;
    private final Collection onSendErrorHandlerCollection;

    public AggregateMetricSender(String defaultSourceName,
                                 DataPointReceiverFactory dataPointReceiverFactory,
                                 AuthToken authToken,
                                 Collection onSendErrorHandlerCollection) {
        this(defaultSourceName, dataPointReceiverFactory, null, authToken,
                onSendErrorHandlerCollection);
    }

    public AggregateMetricSender(String defaultSourceName,
                                 EventReceiverFactory eventReceiverFactory, AuthToken authToken,
                                 Collection onSendErrorHandlerCollection) {
        this(defaultSourceName, null, eventReceiverFactory, authToken,
                onSendErrorHandlerCollection);
    }

    public AggregateMetricSender(String defaultSourceName,
                                 DataPointReceiverFactory dataPointReceiverFactory,
                                 EventReceiverFactory eventReceiverFactory, AuthToken authToken,
                                 Collection onSendErrorHandlerCollection) {
        this.defaultSourceName = requireNonNull(defaultSourceName, "defaultSourceName must be a non-null value");
        this.dataPointReceiverFactory = dataPointReceiverFactory;
        this.eventReceiverFactory = eventReceiverFactory;
        this.authToken = authToken;
        this.onSendErrorHandlerCollection = onSendErrorHandlerCollection;

        this.registeredMetricPairs = new HashSet();
    }

    public String getDefaultSourceName() {
        return defaultSourceName;
    }

    private void communicateError(String message, MetricErrorType code,
                                  SignalFxMetricsException signalfxMetricsException) {
        for (OnSendErrorHandler onSendErrorHandler : onSendErrorHandlerCollection) {
            onSendErrorHandler
                    .handleError(new MetricErrorImpl(message, code, signalfxMetricsException));
        }
    }

    public Session createSession() {
        return new SessionImpl();
    }

    private final class SessionImpl implements Session {
        private final Map toBeRegisteredMetricPairs;
        private final List pointsToFlush;
        private final List eventsToFlush;

        private SessionImpl() {
            toBeRegisteredMetricPairs = new HashMap();

            pointsToFlush = new ArrayList();
            eventsToFlush = new ArrayList();
        }

        @Override
        public Session setCumulativeCounter(String metric, long value) {
            return setCumulativeCounter(defaultSourceName, metric, value);
        }

        @Override
        public Session setCumulativeCounter(String source, String metric, long value) {
            setDatapoint(source, metric, SignalFxProtocolBuffers.MetricType.CUMULATIVE_COUNTER, value);
            return this;
        }

        @Override
        public Session incrementCounter(String metric, long value) {
            return incrementCounter(defaultSourceName, metric, value);
        }

        @Override
        public Session incrementCounter(String source, String metric, long value) {
            setDatapoint(source, metric, SignalFxProtocolBuffers.MetricType.COUNTER, value);
            return this;
        }

        @Override
        public Session setDatapoint(String source, String metric,
                                              SignalFxProtocolBuffers.MetricType metricType,
                                              long value) {
            check(metric, metricType);
            pointsToFlush.add(SignalFxProtocolBuffers.DataPoint.newBuilder()
                                      .setSource(source)
                                      .setMetricType(metricType)
                                      .setMetric(metric).setValue(
                            SignalFxProtocolBuffers.Datum.newBuilder().setIntValue(value).build())
                                      .build());
            return this;
        }

        @Override
        public Session setDatapoint(String source, String metric,
                                              SignalFxProtocolBuffers.MetricType metricType,
                                              double value) {
            check(metric, metricType);
            pointsToFlush.add(SignalFxProtocolBuffers.DataPoint.newBuilder()
                                      .setSource(source)
                                      .setMetricType(metricType)
                                      .setMetric(metric).setValue(
                            SignalFxProtocolBuffers.Datum.newBuilder().setDoubleValue(value).build())
                                      .build());
            return this;
        }

        @Override
        public Session setDatapoint(SignalFxProtocolBuffers.DataPoint datapoint) {
            check(datapoint.getMetric(), datapoint.getMetricType());
            pointsToFlush.add(datapoint);
            return this;
        }

        @Override
        public Session setEvent(SignalFxProtocolBuffers.Event event) {
            eventsToFlush.add(event);
            return this;
        }

        @Override
        public Session setGauge(String metric, long value) {
            return setGauge(defaultSourceName, metric, value);
        }

        @Override
        public Session setGauge(String source, String metric, long value) {
            setDatapoint(source, metric, SignalFxProtocolBuffers.MetricType.GAUGE, value);
            return this;
        }

        @Override
        public Session setGauge(String metric, double value) {
            return setGauge(defaultSourceName, metric, value);
        }

        @Override
        public Session setGauge(String source, String metric, double value) {
            setDatapoint(source, metric, SignalFxProtocolBuffers.MetricType.GAUGE, value);
            return this;
        }

        private void check(String metricPair,
                           SignalFxProtocolBuffers.MetricType
                                   metricType) {
            if (!registeredMetricPairs.contains(metricPair)) {
                toBeRegisteredMetricPairs.put(metricPair, metricType);
            }
        }

        @Override
        public void close() {
            final String authTokenStr;
            try {
                authTokenStr = authToken.getAuthToken();
            } catch (NoAuthTokenException e) {
                communicateError("Unable to get auth token", MetricErrorType.AUTH_TOKEN_ERROR, e);
                return;
            }

            flushDatapoints(authTokenStr);
            flushEvents(authTokenStr);
        }

        private void flushDatapoints(String authTokenStr) {
            if (pointsToFlush.isEmpty()) {
                return;
            }

            if (dataPointReceiverFactory == null) {
                communicateError("DataPointReceiverFactory object is not set",
                        MetricErrorType.DATAPOINT_SEND_ERROR, new SignalFxMetricsException());
                return;
            }

            DataPointReceiver dataPointReceiver = dataPointReceiverFactory
                    .createDataPointReceiver();

            if (!toBeRegisteredMetricPairs.isEmpty()) {
                try {
                    Map registeredPairs = dataPointReceiver
                            .registerMetrics(authTokenStr, toBeRegisteredMetricPairs);
                    for (Map.Entry i : registeredPairs.entrySet()) {
                        if (i.getValue()) {
                            registeredMetricPairs.add(i.getKey());
                        }
                    }
                } catch (SignalFxMetricsException e) {
                    communicateError("Unable to register metrics",
                            MetricErrorType.REGISTRATION_ERROR, e);
                    return;
                }
            }

            Iterator i = pointsToFlush.iterator();
            while (i.hasNext()) {
                SignalFxProtocolBuffers.DataPoint currentEntry = i.next();
                if (!registeredMetricPairs.contains(currentEntry.getMetric())) {
                    i.remove();
                }
            }

            try {
                dataPointReceiver.addDataPoints(authTokenStr, pointsToFlush);
            } catch (SignalFxMetricsException e) {
                communicateError("Unable to send datapoints", MetricErrorType.DATAPOINT_SEND_ERROR,
                        e);
            }
        }

        private void flushEvents(String authTokenStr) {
            if (eventsToFlush.isEmpty()) {
                return;
            }

            if (eventReceiverFactory == null) {
                communicateError("EventReceiverFactory object is not set",
                        MetricErrorType.EVENT_SEND_ERROR, new SignalFxMetricsException());
                return;
            }

            try {
                EventReceiver eventReceiver = eventReceiverFactory.createEventReceiver();
                eventReceiver.addEvents(authTokenStr, eventsToFlush);
            } catch (SignalFxMetricsException e) {
                communicateError("Unable to send events", MetricErrorType.EVENT_SEND_ERROR, e);
            }
        }
    }

    public interface Session extends Closeable {
        Session setCumulativeCounter(String metric, long value);

        Session setCumulativeCounter(String source, String metric, long value);

        Session setGauge(String metric, long value);

        Session setGauge(String source, String metric, long value);

        Session setGauge(String metric, double value);

        Session setGauge(String source, String metric, double value);

        Session incrementCounter(String metric, long value);

        Session incrementCounter(String source, String metric, long value);

        Session setDatapoint(String source, String metric, SignalFxProtocolBuffers.MetricType metricType, long value);

        Session setDatapoint(String source, String metric, SignalFxProtocolBuffers.MetricType metricType, double value);

        Session setDatapoint(SignalFxProtocolBuffers.DataPoint datapoint);

        Session setEvent(SignalFxProtocolBuffers.Event event);
    }
}