com.signalfuse.metrics.connection.HttpDataPointProtobufReceiverConnection Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of signalfuse-java Show documentation
Bare minimum core library needed to sending metrics to SignalFuse from Java clients
There is a newer version: 0.0.19
package com.signalfuse.metrics.connection;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.io.IOUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.conn.HttpClientConnectionManager;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.InputStreamEntity;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.ImmutableMap;
import com.signalfuse.common.proto.ProtocolBufferStreamingInputStream;
import com.signalfuse.endpoint.SignalFuseReceiverEndpoint;
import com.signalfuse.metrics.SignalfuseMetricsException;
import com.signalfuse.metrics.protobuf.SignalFuseProtocolBuffers;

public class HttpDataPointProtobufReceiverConnection
        extends AbstractHttpDataPointProtobufReceiverConnection {
    public HttpDataPointProtobufReceiverConnection(
            SignalFuseReceiverEndpoint endpoint, int timeoutMs,
            HttpClientConnectionManager httpClientConnectionManager) {
        super(endpoint, timeoutMs, httpClientConnectionManager);
    }

    @Override
    protected HttpEntity getEntityForVersion(List dataPoints) {
        return new InputStreamEntity(
                new ProtocolBufferStreamingInputStream(
                        dataPoints.iterator()), PROTO_TYPE);
    }

    @Override
    protected String getEndpointForAddDatapoints() {
        return "/v1/datapoint";
    }

    @Override
    public Map registerMetrics(String auth,
                                                Map metricTypes)
            throws SignalfuseMetricsException {
        Map res = new HashMap();
        for (Map.Entry i : metricTypes.entrySet()) {
            res.put(i.getKey(), false);
        }
        if (metricTypes.isEmpty()) {
            return res;
        }
        List> postBodyList = new ArrayList>(
                metricTypes.size());
        for (Map.Entry entity : metricTypes
                .entrySet()) {
            postBodyList.add(ImmutableMap
                    .of("sf_metric", entity.getKey(), "sf_metricType",
                            entity.getValue().toString()));
        }

        final byte[] map_as_json;
        try {
            map_as_json = MAPPER.writeValueAsBytes(postBodyList);
        } catch (JsonProcessingException e) {
            throw new SignalfuseMetricsException("Unable to write protocol buffer", e);
        }
        String body = "";
        try {
            CloseableHttpResponse resp = null;
            try {
                resp = postToEndpoint(auth,
                        new ByteArrayEntity(map_as_json, JSON_TYPE), "/v1/metric?bulkupdate=true");
                try {
                    body = IOUtils.toString(resp.getEntity().getContent());
                } catch (IOException e) {
                    throw new SignalfuseMetricsException("Unable to get reponse content",
                            e);
                }
                if (resp.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
                    throw new SignalfuseMetricsException("Invalid status code "
                            + resp.getStatusLine().getStatusCode() + ": " + body);
                }
                List> respObject =
                        new ObjectMapper().readValue(body.getBytes(),
                                new TypeReference>>() {
                                });
                if (respObject.size() != metricTypes.size()) {
                    throw new SignalfuseMetricsException(
                            String.format("json map mismatch: post_body=%s, resp=%s",
                                    new String(map_as_json), body));
                }
                for (int i = 0; i < respObject.size(); i++) {
                    Map m = respObject.get(i);
                    if (!m.containsKey("code") || "409".equals(m.get("code").toString())) {
                        res.put(postBodyList.get(i).get("sf_metric"), true);
                    }
                }
            } finally {
                if (resp != null) {
                    resp.close();
                }
            }
        } catch (IOException e) {
            throw new SignalfuseMetricsException(
                    String.format("post_body=%s, resp=%s", new String(map_as_json), body), e);
        }
        return res;
    }
}