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.HashMap;
  14 import java.util.Iterator;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Random;
  18 import java.util.UUID;
  19
  20 import jalview.bin.Cache;
  21 import jalview.bin.Console;
  22 import jalview.util.ChannelProperties;
  23
  24 public class GoogleAnalytics4
  25 {
  26   private static final String JALVIEW_ID = "Jalview Desktop";
  27
  28   private static final String SESSION_ID = new Random().toString();
  29
  30   private static final String MEASUREMENT_ID = "G-6TMPHMXEQ0";
  31
  32   private static final String API_SECRET = "Qb9NSbqkRDqizG6j2BBJ2g";
  33
  34   // This will generate a different CLIENT_ID each time the application is
  35   // launched. Do we want to store it in .jalview_properties?
  36   private static final String CLIENT_ID = UUID.randomUUID().toString();
  37
  38   private static final String BASE_URL = "https://www.google-analytics.com/mp/collect";
  39
  40   private static final String DESKTOP_EVENT = "desktop_event";
  41
  42   private List<Map.Entry<String, String>> queryStringValues;
  43
  44   private List<Map.Entry<String, Object>> jsonObject;
  45
  46   private List<Event> events;
  47
  48   private List<Map.Entry<String, String>> cookieValues;
  49
  50   private static boolean ENABLED = false;
  51
  52   private static GoogleAnalytics4 instance = null;
  53
  54   private static final Map<String, String> defaultParams;
  55
  56   static
  57   {
  58     defaultParams = new HashMap<>();
  59     defaultParams.put("app_name",
  60             ChannelProperties.getProperty("app_name") + " Desktop");
  61     defaultParams.put("version", Cache.getProperty("VERSION"));
  62     defaultParams.put("build_date",
  63             Cache.getDefault("BUILD_DATE", "unknown"));
  64     defaultParams.put("java_version", System.getProperty("java.version"));
  65     String val = System.getProperty("sys.install4jVersion");
  66     if (val != null)
  67     {
  68       defaultParams.put("install4j_version", val);
  69     }
  70     val = System.getProperty("installer_template_version");
  71     if (val != null)
  72     {
  73       defaultParams.put("install4j_template_version", val);
  74     }
  75     val = System.getProperty("launcher_version");
  76     if (val != null)
  77     {
  78       defaultParams.put("launcher_version", val);
  79     }
  80     defaultParams.put("java_arch",
  81             System.getProperty("os.arch") + " "
  82                     + System.getProperty("os.name") + " "
  83                     + System.getProperty("os.version"));
  84   }
  85
  86   private GoogleAnalytics4()
  87   {
  88     this.resetLists();
  89   }
  90
  91   public static void setEnabled(boolean b)
  92   {
  93     ENABLED = b;
  94   }
  95
  96   public void sendAnalytics(String eventName, String... paramsStrings)
  97   {
  98     sendAnalytics(eventName, false, paramsStrings);
  99   }
 100
 101   /**
 102    * The simplest way to send an analytic event.
 103    *
 104    * @param eventName
 105    *          The event name. To emulate a webpage view use "page_view" and set
 106    *          a "page_location" parameter. See
 107    *          https://developers.google.com/analytics/devguides/collection/ga4/events?client_type=gtag
 108    * @param sendDefaultParams
 109    *          Flag whether to add the default params about the application.
 110    * @param paramsStrings
 111    *          Optional multiple Strings in key, value pairs (there should be an
 112    *          even number of paramsStrings) to be set as parameters of the
 113    *          event. To emulate a webpage view use "page_location" as the URL in
 114    *          a "page_view" event.
 115    */
 116   public void sendAnalytics(String eventName, boolean sendDefaultParams,
 117           String... paramsStrings)
 118   {
 119     // clear out old lists
 120     this.resetLists();
 121
 122     if (!ENABLED)
 123     {
 124       Console.debug("GoogleAnalytics4 not enabled.");
 125       return;
 126     }
 127     Map<String, String> params = new HashMap<>();
 128     params.put("event_category", DESKTOP_EVENT);
 129     params.put("event_label", eventName);
 130
 131     // add these to all events from this application instance
 132     if (sendDefaultParams)
 133     {
 134       params.putAll(defaultParams);
 135     }
 136
 137     // add (and overwrite with) the passed in params
 138     if (paramsStrings != null && paramsStrings.length > 0)
 139     {
 140       if (paramsStrings.length % 2 != 0)
 141       {
 142         Console.warn(
 143                 "Cannot addEvent with odd number of paramsStrings.  Ignoring the last one.");
 144       }
 145       for (int i = 0; i < paramsStrings.length - 1; i += 2)
 146       {
 147         String key = paramsStrings[i];
 148         String value = paramsStrings[i + 1];
 149         params.put(key, value);
 150       }
 151     }
 152
 153     addEvent(eventName, params);
 154     addQueryStringValue("measurement_id", MEASUREMENT_ID);
 155     addQueryStringValue("api_secret", API_SECRET);
 156     addJsonValue("client_id", CLIENT_ID);
 157     addJsonValues("events", Event.toObjectList(events));
 158     StringBuilder urlSb = new StringBuilder();
 159     urlSb.append(BASE_URL);
 160     urlSb.append('?');
 161     urlSb.append(buildQueryString());
 162     try
 163     {
 164       URL url = new URL(urlSb.toString());
 165       URLConnection urlConnection = url.openConnection();
 166       HttpURLConnection httpURLConnection = (HttpURLConnection) urlConnection;
 167       httpURLConnection.setRequestMethod("POST");
 168       httpURLConnection.setDoOutput(true);
 169
 170       String jsonString = buildJson();
 171
 172       Console.debug("GA4: HTTP Request is: '" + urlSb.toString() + "'");
 173       Console.debug("GA4: POSTed JSON is:\n" + jsonString);
 174
 175       byte[] jsonBytes = jsonString.getBytes(StandardCharsets.UTF_8);
 176       int jsonLength = jsonBytes.length;
 177
 178       httpURLConnection.setFixedLengthStreamingMode(jsonLength);
 179       httpURLConnection.setRequestProperty("Content-Type",
 180               "application/json; charset=UTF-8");
 181       httpURLConnection.connect();
 182       try (OutputStream os = httpURLConnection.getOutputStream())
 183       {
 184         os.write(jsonBytes);
 185       }
 186       int responseCode = httpURLConnection.getResponseCode();
 187       String responseMessage = httpURLConnection.getResponseMessage();
 188       if (responseCode < 200 || responseCode > 299)
 189       {
 190         Console.warn("GoogleAnalytics4 connection failed: '" + responseCode
 191                 + " " + responseMessage + "'");
 192       }
 193       else
 194       {
 195         Console.debug("GoogleAnalytics4 connection succeeded: '"
 196                 + responseCode + " " + responseMessage + "'");
 197       }
 198     } catch (MalformedURLException e)
 199     {
 200       Console.debug(
 201               "Somehow the GoogleAnalytics4 BASE_URL and queryString is malformed.",
 202               e);
 203       return;
 204     } catch (IOException e)
 205     {
 206       Console.debug("Connection to GoogleAnalytics4 BASE_URL '" + BASE_URL
 207               + "' failed.", e);
 208     } catch (ClassCastException e)
 209     {
 210       Console.debug(
 211               "Couldn't cast URLConnection to HttpURLConnection in GoogleAnalytics4.",
 212               e);
 213     }
 214   }
 215
 216   public void addEvent(String name, Map<String, String> params)
 217   {
 218     Event event = new Event(name);
 219     if (params != null && params.size() > 0)
 220     {
 221       for (String key : params.keySet())
 222       {
 223         String value = params.get(key);
 224         event.addParam(key, value);
 225       }
 226     }
 227     events.add(event);
 228   }
 229
 230   private void addJsonObject(String key,
 231           List<Map.Entry<String, Object>> object)
 232   {
 233     jsonObject.add(objectEntry(key, object));
 234   }
 235
 236   private void addJsonValues(String key, List<Object> values)
 237   {
 238     jsonObject.add(objectEntry(key, values));
 239   }
 240
 241   private void addJsonValue(String key, String value)
 242   {
 243     jsonObject.add(objectEntry(key, value));
 244   }
 245
 246   private void addJsonValue(String key, int value)
 247   {
 248     jsonObject.add(objectEntry(key, Integer.valueOf(value)));
 249   }
 250
 251   private void addJsonValue(String key, boolean value)
 252   {
 253     jsonObject.add(objectEntry(key, Boolean.valueOf(value)));
 254   }
 255
 256   private void addQueryStringValue(String key, String value)
 257   {
 258     queryStringValues.add(stringEntry(key, value));
 259   }
 260
 261   private void addCookieValue(String key, String value)
 262   {
 263     cookieValues.add(stringEntry(key, value));
 264   }
 265
 266   private void resetLists()
 267   {
 268     jsonObject = new ArrayList<>();
 269     events = new ArrayList<Event>();
 270     queryStringValues = new ArrayList<>();
 271     cookieValues = new ArrayList<>();
 272   }
 273
 274   public static GoogleAnalytics4 getInstance()
 275   {
 276     if (instance == null)
 277     {
 278       instance = new GoogleAnalytics4();
 279     }
 280     return instance;
 281   }
 282
 283   public static void reset()
 284   {
 285     getInstance().resetLists();
 286   }
 287
 288   private String buildQueryString()
 289   {
 290     StringBuilder sb = new StringBuilder();
 291     for (Map.Entry<String, String> entry : queryStringValues)
 292     {
 293       if (sb.length() > 0)
 294       {
 295         sb.append('&');
 296       }
 297       sb.append(URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8));
 298       sb.append('=');
 299       sb.append(
 300               URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8));
 301     }
 302     return sb.toString();
 303   }
 304
 305   private void buildCookieHeaders()
 306   {
 307     // TODO not needed yet
 308   }
 309
 310   private String buildJson()
 311   {
 312     StringBuilder sb = new StringBuilder();
 313     addJsonObject(sb, 0, jsonObject);
 314     return sb.toString();
 315   }
 316
 317   private void addJsonObject(StringBuilder sb, int indent,
 318           List<Map.Entry<String, Object>> entries)
 319   {
 320     indent(sb, indent);
 321     sb.append('{');
 322     newline(sb);
 323     Iterator<Map.Entry<String, Object>> entriesI = entries.iterator();
 324     while (entriesI.hasNext())
 325     {
 326       Map.Entry<String, Object> entry = entriesI.next();
 327       String key = entry.getKey();
 328       // TODO sensibly escape " characters in key
 329       Object value = entry.getValue();
 330       indent(sb, indent + 1);
 331       sb.append('"').append(quoteEscape(key)).append('"').append(':');
 332       space(sb);
 333       if (value != null && value instanceof List)
 334       {
 335         newline(sb);
 336       }
 337       addJsonValue(sb, indent + 2, value);
 338       if (entriesI.hasNext())
 339       {
 340         sb.append(',');
 341       }
 342       newline(sb);
 343     }
 344     indent(sb, indent);
 345     sb.append('}');
 346   }
 347
 348   private void addJsonValue(StringBuilder sb, int indent, Object value)
 349   {
 350     if (value == null)
 351     {
 352       return;
 353     }
 354     try
 355     {
 356       if (value instanceof Map.Entry)
 357       {
 358         Map.Entry<String, Object> entry = (Map.Entry<String, Object>) value;
 359         List<Map.Entry<String, Object>> object = new ArrayList<>();
 360         object.add(entry);
 361         addJsonObject(sb, indent, object);
 362       }
 363       else if (value instanceof List)
 364       {
 365         // list of Map.Entries or list of values?
 366         List<Object> valueList = (List<Object>) value;
 367         if (valueList.size() > 0 && valueList.get(0) instanceof Map.Entry)
 368         {
 369           // entries
 370           // indent(sb, indent);
 371           List<Map.Entry<String, Object>> entryList = (List<Map.Entry<String, Object>>) value;
 372           addJsonObject(sb, indent, entryList);
 373         }
 374         else
 375         {
 376           // values
 377           indent(sb, indent);
 378           sb.append('[');
 379           newline(sb);
 380           Iterator<Object> valueListI = valueList.iterator();
 381           while (valueListI.hasNext())
 382           {
 383             Object v = valueListI.next();
 384             addJsonValue(sb, indent + 1, v);
 385             if (valueListI.hasNext())
 386             {
 387               sb.append(',');
 388             }
 389             newline(sb);
 390           }
 391           indent(sb, indent);
 392           sb.append("]");
 393         }
 394       }
 395       else if (value instanceof String)
 396       {
 397         sb.append('"').append(quoteEscape((String) value)).append('"');
 398       }
 399       else if (value instanceof Integer)
 400       {
 401         sb.append(((Integer) value).toString());
 402       }
 403       else if (value instanceof Boolean)
 404       {
 405         sb.append('"').append(((Boolean) value).toString()).append('"');
 406       }
 407     } catch (ClassCastException e)
 408     {
 409       Console.debug(
 410               "Could not deal with type of json Object " + value.toString(),
 411               e);
 412     }
 413   }
 414
 415   private static String quoteEscape(String s)
 416   {
 417     if (s == null)
 418     {
 419       return null;
 420     }
 421     // this escapes quotation marks (") that aren't already escaped (in the
 422     // string) ready to go into a quoted JSON string value
 423     return s.replaceAll("((?<!\\\\)(?:\\\\{2})*)\"", "$1\\\\\"");
 424   }
 425
 426   private static void prettyWhitespace(StringBuilder sb, String whitespace,
 427           int repeat)
 428   {
 429     // only add whitespace if we're in DEBUG mode
 430     if (!Console.getLogger().isDebugEnabled())
 431     {
 432       return;
 433     }
 434     if (repeat >= 0 && whitespace != null)
 435     {
 436       sb.append(whitespace.repeat(repeat));
 437     }
 438     else
 439     {
 440       sb.append(whitespace);
 441     }
 442   }
 443
 444   private static void indent(StringBuilder sb, int indent)
 445   {
 446     prettyWhitespace(sb, "  ", indent);
 447   }
 448
 449   private static void newline(StringBuilder sb)
 450   {
 451     prettyWhitespace(sb, "\n", -1);
 452   }
 453
 454   private static void space(StringBuilder sb)
 455   {
 456     prettyWhitespace(sb, " ", -1);
 457   }
 458
 459   protected static Map.Entry<String, Object> objectEntry(String s, Object o)
 460   {
 461     return new AbstractMap.SimpleEntry<String, Object>(s, o);
 462   }
 463
 464   protected static Map.Entry<String, String> stringEntry(String s, String v)
 465   {
 466     return new AbstractMap.SimpleEntry<String, String>(s, v);
 467   }
 468 }
 469
 470 class Event
 471 {
 472   private String name;
 473
 474   private List<Map.Entry<String, String>> params;
 475
 476   @SafeVarargs
 477   public Event(String name, Map.Entry<String, String>... paramEntries)
 478   {
 479     this.name = name;
 480     this.params = new ArrayList<Map.Entry<String, String>>();
 481     for (Map.Entry<String, String> paramEntry : paramEntries)
 482     {
 483       if (paramEntry == null)
 484       {
 485         continue;
 486       }
 487       params.add(paramEntry);
 488     }
 489   }
 490
 491   public void addParam(String param, String value)
 492   {
 493     params.add(GoogleAnalytics4.stringEntry(param, value));
 494   }
 495
 496   protected List<Map.Entry<String, Object>> toObject()
 497   {
 498     List<Map.Entry<String, Object>> object = new ArrayList<>();
 499     object.add(GoogleAnalytics4.objectEntry("name", (Object) name));
 500     if (params.size() > 0)
 501     {
 502       object.add(GoogleAnalytics4.objectEntry("params", (Object) params));
 503     }
 504     return object;
 505   }
 506
 507   protected static List<Object> toObjectList(List<Event> events)
 508   {
 509     List<Object> eventObjectList = new ArrayList<>();
 510     for (Event event : events)
 511     {
 512       eventObjectList.add((Object) event.toObject());
 513     }
 514     return eventObjectList;
 515   }
 516 }