com.groupbyinc.common.blip.BlipClient Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of common-blip-client Show documentation
${project.name}
There is a newer version: 198
package com.groupbyinc.common.blip;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
import org.joda.time.format.DateTimeFormatter;
import org.joda.time.format.ISODateTimeFormat;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.net.SocketTimeoutException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;

@SuppressWarnings("WeakerAccess")
public class BlipClient {

    private static final transient Logger LOG = LoggerFactory.getLogger(BlipClient.class);
    private static final HttpClient CLIENT = createHttpClient();
    private static final ObjectMapper OM = new ObjectMapper();
    private static final Charset UTF8 = Charset.forName("UTF-8");
    private static final String APPLICATION_JSON = "application/json";
    private static final DateTimeFormatter ISO8601 = ISODateTimeFormat.dateTime();
    private static final int CONNECT_TIMEOUT = 10;
    private static final int CONNECTION_REQUEST_TIMEOUT = 10;
    private static final int SOCKET_TIMEOUT = 10;
    @SuppressWarnings("unused")
    public static final BlipClient EMPTY  = new EmptyBlipClient();
    private int connectTimeout = CONNECT_TIMEOUT;
    private int connectionRequestTimeout = CONNECTION_REQUEST_TIMEOUT;
    private int socketTimeout = SOCKET_TIMEOUT;

    private static class EmptyBlipClient extends BlipClient {

        EmptyBlipClient() {
            super("http://localhost:1000", null, null);
        }

        @Override
        public void send(Map values) {
            // do nothing
        }
        @Override
        public void send(String...keyValues) {
            // do nothing
        }
    }

    private final String service;
    private URI uri = null;
    private final String environment;

    @SuppressWarnings("WeakerAccess")
    public BlipClient(String uri, String environment, String service) {
        try {
            this.uri = new URI(uri);
            this.environment = environment;
            this.service = service;
        } catch (URISyntaxException e) {
            throw new IllegalStateException("Couldn't create BlipClient", e);
        }
    }


    private static HttpClient createHttpClient() {
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
        cm.setMaxTotal(200);
        cm.setDefaultMaxPerRoute(200);
        HttpClientBuilder clientBuilder = HttpClientBuilder.create();
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectTimeout(CONNECT_TIMEOUT)
                .setConnectionRequestTimeout(CONNECTION_REQUEST_TIMEOUT)
                .setSocketTimeout(SOCKET_TIMEOUT).build();
        return clientBuilder.setConnectionManager(cm)
                .setDefaultRequestConfig(requestConfig).build();
    }


    public void send(String...keyValues) {
        Map keyValueMap = new HashMap();
        if (keyValues != null) {
            for (int i = 0; i < keyValues.length; i += 2) {
                keyValueMap.put(keyValues[i], keyValues[i + 1]);
            }
        }
        send(keyValueMap);
    }

    public void send(final Map values) {
        if (!values.containsKey("eventType") || StringUtils.isBlank(values.get("eventType"))) {
            throw new IllegalStateException("No eventType found in blip map.  " +
                    "You must define an eventType or we can't use this information.");
        }
        new Thread(new Runnable() {
            @Override
            public void run() {
                sendMap(values);
            }
        }).start();
    }

    private void sendMap(Map values) {
        try {
            values.put("environment", environment);
            values.put("service", service);
            if (!values.containsKey("date")){
                values.put("date", DateTime.now(DateTimeZone.UTC).toString(ISO8601));
            }
            String json = OM.writeValueAsString(values);
            StringEntity entity = new StringEntity(json, UTF8);
            entity.setContentType(APPLICATION_JSON);
            HttpPost post = new HttpPost(uri);
            post.setEntity(entity);
            LOG.info("posting");
            CLIENT.execute(post);
        } catch (SocketTimeoutException e) {
            // swallow
        } catch (Exception e) {
            LOG.warn("Could not send blip", e);
        }
    }

    @SuppressWarnings("unused")
    public int getSocketTimeout() {
        return socketTimeout;
    }

    @SuppressWarnings("unused")
    public void setSocketTimeout(int socketTimeout) {
        this.socketTimeout = socketTimeout;
    }

    @SuppressWarnings("unused")
    public int getConnectionRequestTimeout() {
        return connectionRequestTimeout;
    }

    @SuppressWarnings("unused")
    public void setConnectionRequestTimeout(int connectionRequestTimeout) {
        this.connectionRequestTimeout = connectionRequestTimeout;
    }

    @SuppressWarnings("unused")
    public int getConnectTimeout() {
        return connectTimeout;
    }

    @SuppressWarnings("unused")
    public void setConnectTimeout(int connectTimeout) {
        this.connectTimeout = connectTimeout;
    }
}