src/jalview/analytics/Plausible.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.analytics;
  22
  23 import java.io.BufferedReader;
  24 import java.io.IOException;
  25 import java.io.InputStreamReader;
  26 import java.io.OutputStream;
  27 import java.io.UnsupportedEncodingException;
  28 import java.lang.invoke.MethodHandles;
  29 import java.net.HttpURLConnection;
  30 import java.net.MalformedURLException;
  31 import java.net.URL;
  32 import java.net.URLConnection;
  33 import java.net.URLEncoder;
  34 import java.nio.charset.StandardCharsets;
  35 import java.util.AbstractMap;
  36 import java.util.ArrayList;
  37 import java.util.Collections;
  38 import java.util.HashMap;
  39 import java.util.Iterator;
  40 import java.util.List;
  41 import java.util.Map;
  42 import java.util.Random;
  43
  44 import jalview.bin.Cache;
  45 import jalview.bin.Console;
  46 import jalview.util.ChannelProperties;
  47 import jalview.util.HttpUtils;
  48
  49 public class Plausible
  50 {
  51   private static final String USER_AGENT;
  52
  53   private static final String JALVIEW_ID = "Jalview Desktop";
  54
  55   private static final String DOMAIN = "jalview.org";
  56
  57   private static final String CONFIG_API_BASE_URL = "https://www.jalview.org/services/config/analytics/url";
  58
  59   private static final String DEFAULT_API_BASE_URL = "https://analytics.jalview.org/api/event";
  60
  61   private static final String API_BASE_URL;
  62
  63   private static final String clientId;
  64
  65   public static final String APPLICATION_BASE_URL = "desktop://localhost";
  66
  67   private List<Map.Entry<String, String>> queryStringValues;
  68
  69   private List<Map.Entry<String, Object>> jsonObject;
  70
  71   private List<Map.Entry<String, String>> cookieValues;
  72
  73   private static boolean ENABLED = false;
  74
  75   private static boolean DEBUG = true;
  76
  77   private static Plausible instance = null;
  78
  79   private static final Map<String, String> defaultProps;
  80
  81   static
  82   {
  83     defaultProps = new HashMap<>();
  84     defaultProps.put("app_name",
  85             ChannelProperties.getProperty("app_name") + " Desktop");
  86     defaultProps.put("version", Cache.getProperty("VERSION"));
  87     defaultProps.put("build_date",
  88             Cache.getDefault("BUILD_DATE", "unknown"));
  89     defaultProps.put("java_version", System.getProperty("java.version"));
  90     String val = System.getProperty("sys.install4jVersion");
  91     if (val != null)
  92     {
  93       defaultProps.put("install4j_version", val);
  94     }
  95     val = System.getProperty("installer_template_version");
  96     if (val != null)
  97     {
  98       defaultProps.put("install4j_template_version", val);
  99     }
 100     val = System.getProperty("launcher_version");
 101     if (val != null)
 102     {
 103       defaultProps.put("launcher_version", val);
 104     }
 105     defaultProps.put("java_arch",
 106             System.getProperty("os.arch") + " "
 107                     + System.getProperty("os.name") + " "
 108                     + System.getProperty("os.version"));
 109     defaultProps.put("os", System.getProperty("os.name"));
 110     defaultProps.put("os_version", System.getProperty("os.version"));
 111     defaultProps.put("os_arch", System.getProperty("os.arch"));
 112     String installation = Cache.applicationProperties
 113             .getProperty("INSTALLATION");
 114     if (installation != null)
 115     {
 116       defaultProps.put("installation", installation);
 117     }
 118
 119     // ascertain the API_BASE_URL
 120     API_BASE_URL = getAPIBaseURL();
 121
 122     // random clientId to make User-Agent unique (to register analytic)
 123     clientId = String.format("%08x", new Random().nextInt());
 124
 125     USER_AGENT = HttpUtils.getUserAgent(
 126             MethodHandles.lookup().lookupClass().getCanonicalName() + " "
 127                     + clientId);
 128   }
 129
 130   private Plausible()
 131   {
 132     this.resetLists();
 133   }
 134
 135   public static void setEnabled(boolean b)
 136   {
 137     ENABLED = b;
 138   }
 139
 140   public void sendEvent(String eventName, String urlString,
 141           String... propsStrings)
 142   {
 143     sendEvent(eventName, urlString, false, propsStrings);
 144   }
 145
 146   /**
 147    * The simplest way to send an analytic event.
 148    *
 149    * @param eventName
 150    *          The event name. To emulate a webpage view use "pageview" and set a
 151    *          "url" key/value. See https://plausible.io/docs/events-api
 152    * @param sendDefaultProps
 153    *          Flag whether to add the default props about the application.
 154    * @param propsStrings
 155    *          Optional multiple Strings in key, value pairs (there should be an
 156    *          even number of propsStrings) to be set as property of the event.
 157    *          To emulate a webpage view set "url" as the URL in a "pageview"
 158    *          event.
 159    */
 160   public void sendEvent(String eventName, String urlString,
 161           boolean sendDefaultProps, String... propsStrings)
 162   {
 163     // clear out old lists
 164     this.resetLists();
 165
 166     if (!ENABLED)
 167     {
 168       Console.debug("Plausible not enabled.");
 169       return;
 170     }
 171     Map<String, String> props = new HashMap<>();
 172
 173     // add these to all events from this application instance
 174     if (sendDefaultProps)
 175     {
 176       props.putAll(defaultProps);
 177     }
 178
 179     // add (and overwrite with) the passed in props
 180     if (propsStrings != null && propsStrings.length > 0)
 181     {
 182       if (propsStrings.length % 2 != 0)
 183       {
 184         Console.warn(
 185                 "Cannot addEvent with odd number of propsStrings.  Ignoring the last one.");
 186       }
 187       for (int i = 0; i < propsStrings.length - 1; i += 2)
 188       {
 189         String key = propsStrings[i];
 190         String value = propsStrings[i + 1];
 191         props.put(key, value);
 192       }
 193     }
 194
 195     addJsonValue("domain", DOMAIN);
 196     addJsonValue("name", eventName);
 197     StringBuilder eventUrlSb = new StringBuilder(APPLICATION_BASE_URL);
 198     if (!APPLICATION_BASE_URL.endsWith("/") && !urlString.startsWith("/"))
 199     {
 200       eventUrlSb.append("/");
 201     }
 202     eventUrlSb.append(urlString);
 203     addJsonValue("url", eventUrlSb.toString());
 204     addJsonObject("props", props);
 205     StringBuilder urlSb = new StringBuilder();
 206     urlSb.append(API_BASE_URL);
 207     String qs = buildQueryString();
 208     if (qs != null && qs.length() > 0)
 209     {
 210       urlSb.append('?');
 211       urlSb.append(qs);
 212     }
 213     try
 214     {
 215       URL url = new URL(urlSb.toString());
 216       URLConnection urlConnection = url.openConnection();
 217       HttpURLConnection httpURLConnection = (HttpURLConnection) urlConnection;
 218       httpURLConnection.setRequestMethod("POST");
 219       httpURLConnection.setDoOutput(true);
 220
 221       String jsonString = buildJson();
 222
 223       Console.debug(
 224               "Plausible: HTTP Request is: '" + urlSb.toString() + "'");
 225       if (DEBUG)
 226       {
 227         Console.debug("Plausible: User-Agent is: '" + USER_AGENT + "'");
 228       }
 229       Console.debug("Plausible: POSTed JSON is:\n" + jsonString);
 230
 231       byte[] jsonBytes = jsonString.getBytes(StandardCharsets.UTF_8);
 232       int jsonLength = jsonBytes.length;
 233
 234       httpURLConnection.setFixedLengthStreamingMode(jsonLength);
 235       httpURLConnection.setRequestProperty("Content-Type",
 236               "application/json");
 237       httpURLConnection.setRequestProperty("User-Agent", USER_AGENT);
 238       httpURLConnection.connect();
 239       try (OutputStream os = httpURLConnection.getOutputStream())
 240       {
 241         os.write(jsonBytes);
 242       }
 243       int responseCode = httpURLConnection.getResponseCode();
 244       String responseMessage = httpURLConnection.getResponseMessage();
 245
 246       if (responseCode < 200 || responseCode > 299)
 247       {
 248         Console.warn("Plausible connection failed: '" + responseCode + " "
 249                 + responseMessage + "'");
 250       }
 251       else
 252       {
 253         Console.debug("Plausible connection succeeded: '" + responseCode
 254                 + " " + responseMessage + "'");
 255       }
 256
 257       if (DEBUG)
 258       {
 259         BufferedReader br = new BufferedReader(new InputStreamReader(
 260                 (httpURLConnection.getInputStream())));
 261         StringBuilder sb = new StringBuilder();
 262         String response;
 263         while ((response = br.readLine()) != null)
 264         {
 265           sb.append(response);
 266         }
 267         String body = sb.toString();
 268         Console.debug("Plausible response content:\n" + body);
 269       }
 270     } catch (MalformedURLException e)
 271     {
 272       Console.debug(
 273               "Somehow the Plausible BASE_URL and queryString is malformed: '"
 274                       + urlSb.toString() + "'",
 275               e);
 276       return;
 277     } catch (IOException e)
 278     {
 279       Console.debug("Connection to Plausible BASE_URL '" + API_BASE_URL
 280               + "' failed.", e);
 281     } catch (ClassCastException e)
 282     {
 283       Console.debug(
 284               "Couldn't cast URLConnection to HttpURLConnection in Plausible.",
 285               e);
 286     }
 287   }
 288
 289   private void addJsonObject(String key, Map<String, String> map)
 290   {
 291     List<Map.Entry<String, ? extends Object>> list = new ArrayList<>();
 292     for (String k : map.keySet())
 293     {
 294       list.add(stringEntry(k, map.get(k)));
 295     }
 296     addJsonObject(key, list);
 297
 298   }
 299
 300   private void addJsonObject(String key,
 301           List<Map.Entry<String, ? extends Object>> object)
 302   {
 303     jsonObject.add(objectEntry(key, object));
 304   }
 305
 306   private void addJsonValues(String key, List<Object> values)
 307   {
 308     jsonObject.add(objectEntry(key, values));
 309   }
 310
 311   private void addJsonValue(String key, String value)
 312   {
 313     jsonObject.add(objectEntry(key, value));
 314   }
 315
 316   private void addJsonValue(String key, int value)
 317   {
 318     jsonObject.add(objectEntry(key, Integer.valueOf(value)));
 319   }
 320
 321   private void addJsonValue(String key, boolean value)
 322   {
 323     jsonObject.add(objectEntry(key, Boolean.valueOf(value)));
 324   }
 325
 326   private void addQueryStringValue(String key, String value)
 327   {
 328     queryStringValues.add(stringEntry(key, value));
 329   }
 330
 331   private void addCookieValue(String key, String value)
 332   {
 333     cookieValues.add(stringEntry(key, value));
 334   }
 335
 336   private void resetLists()
 337   {
 338     jsonObject = new ArrayList<>();
 339     queryStringValues = new ArrayList<>();
 340     cookieValues = new ArrayList<>();
 341   }
 342
 343   public static Plausible getInstance()
 344   {
 345     if (instance == null)
 346     {
 347       instance = new Plausible();
 348     }
 349     return instance;
 350   }
 351
 352   public static void reset()
 353   {
 354     getInstance().resetLists();
 355   }
 356
 357   private String buildQueryString()
 358   {
 359     StringBuilder sb = new StringBuilder();
 360     for (Map.Entry<String, String> entry : queryStringValues)
 361     {
 362       if (sb.length() > 0)
 363       {
 364         sb.append('&');
 365       }
 366       try
 367       {
 368         sb.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
 369       } catch (UnsupportedEncodingException e)
 370       {
 371         sb.append(entry.getKey());
 372       }
 373       sb.append('=');
 374       try
 375       {
 376         sb.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
 377       } catch (UnsupportedEncodingException e)
 378       {
 379         sb.append(entry.getValue());
 380       }
 381     }
 382     return sb.toString();
 383   }
 384
 385   private void buildCookieHeaders()
 386   {
 387     // TODO not needed yet
 388   }
 389
 390   private String buildJson()
 391   {
 392     StringBuilder sb = new StringBuilder();
 393     addJsonObject(sb, 0, jsonObject);
 394     return sb.toString();
 395   }
 396
 397   private void addJsonObject(StringBuilder sb, int indent,
 398           List<Map.Entry<String, Object>> entries)
 399   {
 400     indent(sb, indent);
 401     sb.append('{');
 402     newline(sb);
 403     Iterator<Map.Entry<String, Object>> entriesI = entries.iterator();
 404     while (entriesI.hasNext())
 405     {
 406       Map.Entry<String, Object> entry = entriesI.next();
 407       String key = entry.getKey();
 408       // TODO sensibly escape " characters in key
 409       Object value = entry.getValue();
 410       indent(sb, indent + 1);
 411       sb.append('"').append(quoteEscape(key)).append('"').append(':');
 412       space(sb);
 413       if (value != null && value instanceof List)
 414       {
 415         newline(sb);
 416       }
 417       addJsonValue(sb, indent + 2, value);
 418       if (entriesI.hasNext())
 419       {
 420         sb.append(',');
 421       }
 422       newline(sb);
 423     }
 424     indent(sb, indent);
 425     sb.append('}');
 426   }
 427
 428   private void addJsonValue(StringBuilder sb, int indent, Object value)
 429   {
 430     if (value == null)
 431     {
 432       return;
 433     }
 434     try
 435     {
 436       if (value instanceof Map.Entry)
 437       {
 438         Map.Entry<String, Object> entry = (Map.Entry<String, Object>) value;
 439         List<Map.Entry<String, Object>> object = new ArrayList<>();
 440         object.add(entry);
 441         addJsonObject(sb, indent, object);
 442       }
 443       else if (value instanceof List)
 444       {
 445         // list of Map.Entries or list of values?
 446         List<Object> valueList = (List<Object>) value;
 447         if (valueList.size() > 0 && valueList.get(0) instanceof Map.Entry)
 448         {
 449           // entries
 450           // indent(sb, indent);
 451           List<Map.Entry<String, Object>> entryList = (List<Map.Entry<String, Object>>) value;
 452           addJsonObject(sb, indent, entryList);
 453         }
 454         else
 455         {
 456           // values
 457           indent(sb, indent);
 458           sb.append('[');
 459           newline(sb);
 460           Iterator<Object> valueListI = valueList.iterator();
 461           while (valueListI.hasNext())
 462           {
 463             Object v = valueListI.next();
 464             addJsonValue(sb, indent + 1, v);
 465             if (valueListI.hasNext())
 466             {
 467               sb.append(',');
 468             }
 469             newline(sb);
 470           }
 471           indent(sb, indent);
 472           sb.append("]");
 473         }
 474       }
 475       else if (value instanceof String)
 476       {
 477         sb.append('"').append(quoteEscape((String) value)).append('"');
 478       }
 479       else if (value instanceof Integer)
 480       {
 481         sb.append(((Integer) value).toString());
 482       }
 483       else if (value instanceof Boolean)
 484       {
 485         sb.append('"').append(((Boolean) value).toString()).append('"');
 486       }
 487     } catch (ClassCastException e)
 488     {
 489       Console.debug(
 490               "Could not deal with type of json Object " + value.toString(),
 491               e);
 492     }
 493   }
 494
 495   private static String quoteEscape(String s)
 496   {
 497     if (s == null)
 498     {
 499       return null;
 500     }
 501     // this escapes quotation marks (") that aren't already escaped (in the
 502     // string) ready to go into a quoted JSON string value
 503     return s.replaceAll("((?<!\\\\)(?:\\\\{2})*)\"", "$1\\\\\"");
 504   }
 505
 506   private static void prettyWhitespace(StringBuilder sb, String whitespace,
 507           int repeat)
 508   {
 509     // only add whitespace if we're in DEBUG mode
 510     if (!Console.getLogger().isDebugEnabled())
 511     {
 512       return;
 513     }
 514     if (repeat >= 0 && whitespace != null)
 515     {
 516       // sb.append(whitespace.repeat(repeat));
 517       sb.append(String.join("", Collections.nCopies(repeat, whitespace)));
 518
 519     }
 520     else
 521     {
 522       sb.append(whitespace);
 523     }
 524   }
 525
 526   private static void indent(StringBuilder sb, int indent)
 527   {
 528     prettyWhitespace(sb, "  ", indent);
 529   }
 530
 531   private static void newline(StringBuilder sb)
 532   {
 533     prettyWhitespace(sb, "\n", -1);
 534   }
 535
 536   private static void space(StringBuilder sb)
 537   {
 538     prettyWhitespace(sb, " ", -1);
 539   }
 540
 541   protected static Map.Entry<String, Object> objectEntry(String s, Object o)
 542   {
 543     return new AbstractMap.SimpleEntry<String, Object>(s, o);
 544   }
 545
 546   protected static Map.Entry<String, String> stringEntry(String s, String v)
 547   {
 548     return new AbstractMap.SimpleEntry<String, String>(s, v);
 549   }
 550
 551   private static String getAPIBaseURL()
 552   {
 553     try
 554     {
 555       URL url = new URL(CONFIG_API_BASE_URL);
 556       URLConnection urlConnection = url.openConnection();
 557       HttpURLConnection httpURLConnection = (HttpURLConnection) urlConnection;
 558       httpURLConnection.setRequestMethod("GET");
 559       httpURLConnection.setRequestProperty("User-Agent", USER_AGENT);
 560       httpURLConnection.setConnectTimeout(5000);
 561       httpURLConnection.setReadTimeout(3000);
 562       httpURLConnection.connect();
 563       int responseCode = httpURLConnection.getResponseCode();
 564       String responseMessage = httpURLConnection.getResponseMessage();
 565
 566       if (responseCode < 200 || responseCode > 299)
 567       {
 568         Console.warn("Config URL connection to '" + CONFIG_API_BASE_URL
 569                 + "' failed: '" + responseCode + " " + responseMessage
 570                 + "'");
 571       }
 572
 573       BufferedReader br = new BufferedReader(
 574               new InputStreamReader((httpURLConnection.getInputStream())));
 575       StringBuilder sb = new StringBuilder();
 576       String response;
 577       while ((response = br.readLine()) != null)
 578       {
 579         sb.append(response);
 580       }
 581       if (sb.length() > 7 && sb.substring(0, 5).equals("https"))
 582       {
 583         return sb.toString();
 584       }
 585
 586     } catch (MalformedURLException e)
 587     {
 588       Console.debug("Somehow the config URL is malformed: '"
 589               + CONFIG_API_BASE_URL + "'", e);
 590     } catch (IOException e)
 591     {
 592       Console.debug("Connection to Plausible BASE_URL '" + API_BASE_URL
 593               + "' failed.", e);
 594     } catch (ClassCastException e)
 595     {
 596       Console.debug(
 597               "Couldn't cast URLConnection to HttpURLConnection in Plausible.",
 598               e);
 599     }
 600     return DEFAULT_API_BASE_URL;
 601   }
 602 }