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

package com.groupbyinc.common.blip;

import com.groupbyinc.common.util.ThreadUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BlipClient implements AutoCloseable {

  private static final int CONNECT_TIMEOUT = 100;
  private static final int CONNECTION_REQUEST_TIMEOUT = 100;
  private static final int SOCKET_TIMEOUT = 100;
  @SuppressWarnings("unused") public static final BlipClient EMPTY = new EmptyBlipClient();

  private BlipClientTask task;
  private final CloseableHttpClient httpClient;

  private static class BlipClientQueue {

    private static BlipClientQueue instance = new BlipClientQueue();

    private ExecutorService queue = Executors.newFixedThreadPool(100, ThreadUtils.defaultThreadFactory("blip"));

    private BlipClientQueue() {

    }

    public static BlipClientQueue getInstance() {
      return instance;
    }

    public void offer(final BlipClientTask task) {
      queue.submit(task);
    }
  }

  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
    }
  }

  public BlipClient(String uri, String environment, String service) {
    this(uri, environment, service, createHttpClient());
  }

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

  private static CloseableHttpClient 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 (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.");
    }

    BlipClientQueue.getInstance()
        .offer(task.setValues(values));
  }

  @Override
  public void close() throws Exception {
    if (httpClient != null) {
      httpClient.close();
    }
  }
}