src/jalview/analytics/GoogleAnalytics4.java

   1 package jalview.analytics;
   2
   3 import java.io.IOException;
   4 import java.io.OutputStream;
   5 import java.net.HttpURLConnection;
   6 import java.net.MalformedURLException;
   7 import java.net.URL;
   8 import java.net.URLConnection;
   9 import java.net.URLEncoder;
  10 import java.nio.charset.StandardCharsets;
  11 import java.util.AbstractMap;
  12 import java.util.ArrayList;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.Random;
  16 import java.util.UUID;
  17
  18 import jalview.bin.Console;
  19
  20 public class GoogleAnalytics4
  21 {
  22   private static final String JALVIEW_ID = "Jalview Desktop";
  23
  24   private static final String SESSION_ID = new Random().toString();
  25
  26   private static final String MEASUREMENT_ID = "G-6TMPHMXEQ0";
  27
  28   private static final String API_SECRET = "Qb9NSbqkRDqizG6j2BBJ2g";
  29
  30   // This will generate a different CLIENT_ID each time the application is
  31   // launched. Do we want to store it in .jalview_properties?
  32   private static final String CLIENT_ID = UUID.randomUUID().toString();
  33
  34   private static final String BASE_URL = "https://www.google-analytics.com/mp/collect";
  35
  36   private List<Map.Entry<String, String>> queryStringValues;
  37
  38   private List<Map.Entry<String, Object>> jsonObject;
  39
  40   private List<Event> events;
  41
  42   private List<Map.Entry<String, String>> cookieValues;
  43
  44   private static boolean ENABLED = false;
  45
  46   public GoogleAnalytics4()
  47   {
  48     this.reset();
  49   }
  50
  51   private static void setEnabled(boolean b)
  52   {
  53     ENABLED = b;
  54   }
  55
  56   public void sendAnalytics()
  57   {
  58     sendAnalytics(null);
  59   }
  60
  61   public void sendAnalytics(String path)
  62   {
  63     if (!ENABLED)
  64     {
  65       Console.debug("GoogleAnalytics4 not enabled.");
  66       return;
  67     }
  68     if (path != null)
  69     {
  70       addEvent("page_event", path);
  71     }
  72     addQueryStringValue("measurement_id", MEASUREMENT_ID);
  73     addQueryStringValue("api_secret", API_SECRET);
  74     addJsonValue("client_id", CLIENT_ID);
  75     addJsonValues("events", Event.toObjectList(events));
  76     // addJsonValue("events", )
  77     StringBuilder sb = new StringBuilder();
  78     sb.append(BASE_URL);
  79     sb.append('?');
  80     sb.append(buildQueryString());
  81     try
  82     {
  83       URL url = new URL(sb.toString());
  84       URLConnection urlConnection = url.openConnection();
  85       HttpURLConnection httpURLConnection = (HttpURLConnection) urlConnection;
  86       httpURLConnection.setRequestMethod("POST");
  87       httpURLConnection.setDoOutput(true);
  88
  89       byte[] jsonBytes = buildJson().getBytes(StandardCharsets.UTF_8);
  90       int jsonLength = jsonBytes.length;
  91
  92       httpURLConnection.setFixedLengthStreamingMode(jsonLength);
  93       httpURLConnection.setRequestProperty("Content-Type",
  94               "application/json; charset=UTF-8");
  95       httpURLConnection.connect();
  96       try (OutputStream os = httpURLConnection.getOutputStream())
  97       {
  98         os.write(jsonBytes);
  99       }
 100       int responseCode = httpURLConnection.getResponseCode();
 101       String responseMessage = httpURLConnection.getResponseMessage();
 102       if (responseCode < 200 || responseCode > 299)
 103       {
 104         Console.warn("GoogleAnalytics4 connection failed: '" + responseCode
 105                 + " " + responseMessage + "'");
 106       }
 107       else
 108       {
 109         Console.debug("GoogleAnalytics4 connection succeeded: '"
 110                 + responseCode + " " + responseMessage + "'");
 111       }
 112     } catch (MalformedURLException e)
 113     {
 114       Console.debug(
 115               "Somehow the GoogleAnalytics4 BASE_URL and queryString is malformed.",
 116               e);
 117       return;
 118     } catch (IOException e)
 119     {
 120       Console.debug("Connection to GoogleAnalytics4 BASE_URL '" + BASE_URL
 121               + "' failed.", e);
 122     } catch (ClassCastException e)
 123     {
 124       Console.debug(
 125               "Couldn't cast URLConnection to HttpURLConnection in GoogleAnalytics4.",
 126               e);
 127     }
 128   }
 129
 130   public void addEvent(String name, String... paramsStrings)
 131   {
 132     if (paramsStrings.length % 2 != 0)
 133     {
 134       Console.error(
 135               "Cannot addEvent with odd number of paramsStrings.  Ignoring.");
 136       return;
 137     }
 138     Event event = new Event(name);
 139     for (int i = 0; i < paramsStrings.length - 1; i += 2)
 140     {
 141       String key = paramsStrings[i];
 142       String value = paramsStrings[i + 1];
 143       event.addParam(key, value);
 144     }
 145     events.add(event);
 146   }
 147
 148   private void addJsonObject(String key,
 149           List<Map.Entry<String, Object>> object)
 150   {
 151     jsonObject.add(objectEntry(key, object));
 152   }
 153
 154   private void addJsonValues(String key, List<Object> values)
 155   {
 156     jsonObject.add(objectEntry(key, values));
 157   }
 158
 159   private void addJsonValue(String key, String value)
 160   {
 161     jsonObject.add(objectEntry(key, value));
 162   }
 163
 164   private void addJsonValue(String key, int value)
 165   {
 166     jsonObject.add(objectEntry(key, Integer.valueOf(value)));
 167   }
 168
 169   private void addJsonValue(String key, boolean value)
 170   {
 171     jsonObject.add(objectEntry(key, Boolean.valueOf(value)));
 172   }
 173
 174   private void addQueryStringValue(String key, String value)
 175   {
 176     queryStringValues.add(stringEntry(key, value));
 177   }
 178
 179   private void addCookieValue(String key, String value)
 180   {
 181     cookieValues.add(stringEntry(key, value));
 182   }
 183
 184   public void reset()
 185   {
 186     jsonObject = new ArrayList<>();
 187     events = new ArrayList<Event>();
 188     queryStringValues = new ArrayList<>();
 189     cookieValues = new ArrayList<>();
 190   }
 191
 192   private String buildQueryString()
 193   {
 194     StringBuilder sb = new StringBuilder();
 195     for (Map.Entry<String, String> entry : queryStringValues)
 196     {
 197       if (sb.length() > 0)
 198       {
 199         sb.append('&');
 200       }
 201       sb.append(URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8));
 202       sb.append('=');
 203       sb.append(
 204               URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8));
 205     }
 206     return sb.toString();
 207   }
 208
 209   private void buildCookieHeaders()
 210   {
 211     // TODO not needed yet
 212   }
 213
 214   private String buildJson()
 215   {
 216     StringBuilder sb = new StringBuilder();
 217     addJsonObject(sb, 0, jsonObject);
 218     return sb.toString();
 219   }
 220
 221   private void addJsonObject(StringBuilder sb, int indent,
 222           List<Map.Entry<String, Object>> entries)
 223   {
 224     indent(sb, indent);
 225     sb.append("{\n");
 226     for (Map.Entry<String, Object> entry : entries)
 227     {
 228       String key = entry.getKey();
 229       // TODO sensibly escape " characters in key
 230       Object value = entry.getValue();
 231       indent(sb, indent);
 232       sb.append('"').append(key).append('"');
 233       sb.append(": ");
 234       if (List.class.equals(value.getClass()))
 235       {
 236         sb.append('\n');
 237       }
 238       addJsonValue(sb, indent + 1, value);
 239       sb.append(",\n");
 240     }
 241     sb.append("}\n");
 242   }
 243
 244   private void addJsonValue(StringBuilder sb, int indent, Object value)
 245   {
 246     if (value == null)
 247     {
 248       return;
 249     }
 250     try
 251     {
 252       Class<? extends Object> c = value.getClass();
 253       if (Map.Entry.class.equals(c))
 254       {
 255         Map.Entry<String, Object> entry = (Map.Entry<String, Object>) value;
 256         List<Map.Entry<String, Object>> object = new ArrayList<>();
 257         object.add(entry);
 258         addJsonObject(sb, indent + 1, object);
 259       }
 260       else if (List.class.equals(c))
 261       {
 262         // list of Map.Entries or list of values?
 263         List<Object> valueList = (List<Object>) value;
 264         if (valueList.size() > 0
 265                 && Map.Entry.class.equals(valueList.get(0).getClass()))
 266         {
 267           // entries
 268           indent(sb, indent);
 269           List<Map.Entry<String, Object>> entryList = (List<Map.Entry<String, Object>>) value;
 270           addJsonObject(sb, indent + 1, entryList);
 271         }
 272         else
 273         {
 274           // values
 275           indent(sb, indent);
 276           sb.append("[\n");
 277           for (Object v : valueList)
 278           {
 279             indent(sb, indent + 1);
 280             addJsonValue(sb, indent + 1, v);
 281             sb.append(",\n");
 282           }
 283           indent(sb, indent);
 284           sb.append("]");
 285         }
 286       }
 287       else if (String.class.equals(c))
 288       {
 289         sb.append('"');
 290         sb.append((String) value);
 291         sb.append('"');
 292       }
 293       else if (Integer.class.equals(c))
 294       {
 295         sb.append(((Integer) value).toString());
 296       }
 297       else if (Boolean.class.equals(c))
 298       {
 299         sb.append(((Boolean) value).toString());
 300       }
 301     } catch (ClassCastException e)
 302     {
 303       Console.debug(
 304               "Could not deal with type of jsonObject " + value.toString(),
 305               e);
 306     }
 307   }
 308
 309   private void indent(StringBuilder sb, int indent)
 310   {
 311     sb.append("  ".repeat(indent));
 312   }
 313
 314   protected static Map.Entry<String, Object> objectEntry(String s, Object o)
 315   {
 316     return new AbstractMap.SimpleEntry<String, Object>(s, o);
 317   }
 318
 319   protected static Map.Entry<String, String> stringEntry(String s, String v)
 320   {
 321     return new AbstractMap.SimpleEntry<String, String>(s, v);
 322   }
 323 }
 324
 325 class Event
 326 {
 327   private String name;
 328
 329   private List<Map.Entry<String, String>> params;
 330
 331   @SafeVarargs
 332   public Event(String name, Map.Entry<String, String>... paramEntries)
 333   {
 334     this.name = name;
 335     this.params = new ArrayList<Map.Entry<String, String>>();
 336     for (Map.Entry<String, String> paramEntry : paramEntries)
 337     {
 338       if (paramEntry == null)
 339       {
 340         continue;
 341       }
 342       params.add(paramEntry);
 343     }
 344   }
 345
 346   public void addParam(String param, String value)
 347   {
 348     params.add(GoogleAnalytics4.stringEntry(param, value));
 349   }
 350
 351   protected List<Map.Entry<String, Object>> toObject()
 352   {
 353     List<Map.Entry<String, Object>> object = new ArrayList<>();
 354     object.add(GoogleAnalytics4.objectEntry("name", (Object) name));
 355     if (params.size() > 0)
 356     {
 357       object.add(GoogleAnalytics4.objectEntry("params", (Object) params));
 358     }
 359     return object;
 360   }
 361
 362   protected static List<Object> toObjectList(List<Event> events)
 363   {
 364     List<Object> eventObjectList = new ArrayList<>();
 365     for (Event event : events)
 366     {
 367       eventObjectList.add((Object) event.toObject());
 368     }
 369     return eventObjectList;
 370   }
 371 }