package jalview.analytics;
+import java.io.BufferedReader;
import java.io.IOException;
+import java.io.InputStreamReader;
import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.AbstractMap;
import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
-import java.util.UUID;
+import jalview.bin.Cache;
import jalview.bin.Console;
+import jalview.util.ChannelProperties;
public class GoogleAnalytics4
{
private static final String API_SECRET = "Qb9NSbqkRDqizG6j2BBJ2g";
- // This will generate a different CLIENT_ID each time the application is
- // launched. Do we want to store it in .jalview_properties?
- private static final String CLIENT_ID = UUID.randomUUID().toString();
+ // Client ID must be generated from gtag.js, used and captured.
+ // Will this affect geolocation?
+ private static final String CLIENT_ID = "2092672487.1686663096";
- private static final String BASE_URL = "https://www.google-analytics.com/mp/collect";
+ // set to true to use the GA4 measurement protocol validation service and
+ // print
+ // validation response.
+ // see
+ // https://developers.google.com/analytics/devguides/collection/protocol/ga4/validating-events?client_type=gtag
+ private static boolean DEBUG = false;
+
+ private static final String BASE_URL = "https://www.google-analytics.com/"
+ + (DEBUG ? "debug/" : "") + "mp/collect";
+
+ private static final String DESKTOP_EVENT = "desktop_event";
+
+ public static final String APPLICATION_BASE_URL = "https://www.jalview.org";
private List<Map.Entry<String, String>> queryStringValues;
- private List<Map.Entry<String, Object>> jsonValues;
+ private List<Map.Entry<String, Object>> jsonObject;
+
+ private List<Event> events;
private List<Map.Entry<String, String>> cookieValues;
- public GoogleAnalytics4()
+ private static boolean ENABLED = false;
+
+ private static GoogleAnalytics4 instance = null;
+
+ private static final Map<String, String> defaultParams;
+
+ static
{
- this.reset();
+ defaultParams = new HashMap<>();
+ defaultParams.put("app_name",
+ ChannelProperties.getProperty("app_name") + " Desktop");
+ defaultParams.put("version", Cache.getProperty("VERSION"));
+ defaultParams.put("build_date",
+ Cache.getDefault("BUILD_DATE", "unknown"));
+ defaultParams.put("java_version", System.getProperty("java.version"));
+ String val = System.getProperty("sys.install4jVersion");
+ if (val != null)
+ {
+ defaultParams.put("install4j_version", val);
+ }
+ val = System.getProperty("installer_template_version");
+ if (val != null)
+ {
+ defaultParams.put("install4j_template_version", val);
+ }
+ val = System.getProperty("launcher_version");
+ if (val != null)
+ {
+ defaultParams.put("launcher_version", val);
+ }
+ defaultParams.put("java_arch",
+ System.getProperty("os.arch") + " "
+ + System.getProperty("os.name") + " "
+ + System.getProperty("os.version"));
}
- public void sendAnalytics()
+ private GoogleAnalytics4()
{
- StringBuilder sb = new StringBuilder();
- sb.append(BASE_URL);
- sb.append('?');
- sb.append(buildQueryString());
+ this.resetLists();
+ }
+
+ public static void setEnabled(boolean b)
+ {
+ ENABLED = b;
+ }
+
+ public void sendAnalytics(String eventName, String... paramsStrings)
+ {
+ sendAnalytics(eventName, false, paramsStrings);
+ }
+
+ /**
+ * The simplest way to send an analytic event.
+ *
+ * @param eventName
+ * The event name. To emulate a webpage view use "page_view" and set
+ * a "page_location" parameter. See
+ * https://developers.google.com/analytics/devguides/collection/ga4/events?client_type=gtag
+ * @param sendDefaultParams
+ * Flag whether to add the default params about the application.
+ * @param paramsStrings
+ * Optional multiple Strings in key, value pairs (there should be an
+ * even number of paramsStrings) to be set as parameters of the
+ * event. To emulate a webpage view use "page_location" as the URL in
+ * a "page_view" event.
+ */
+ public void sendAnalytics(String eventName, boolean sendDefaultParams,
+ String... paramsStrings)
+ {
+ // clear out old lists
+ this.resetLists();
+
+ if (!ENABLED)
+ {
+ Console.debug("GoogleAnalytics4 not enabled.");
+ return;
+ }
+ Map<String, String> params = new HashMap<>();
+ params.put("event_category", DESKTOP_EVENT);
+ params.put("event_label", eventName);
+
+ // add these to all events from this application instance
+ if (sendDefaultParams)
+ {
+ params.putAll(defaultParams);
+ }
+
+ // add (and overwrite with) the passed in params
+ if (paramsStrings != null && paramsStrings.length > 0)
+ {
+ if (paramsStrings.length % 2 != 0)
+ {
+ Console.warn(
+ "Cannot addEvent with odd number of paramsStrings. Ignoring the last one.");
+ }
+ for (int i = 0; i < paramsStrings.length - 1; i += 2)
+ {
+ String key = paramsStrings[i];
+ String value = paramsStrings[i + 1];
+ params.put(key, value);
+ }
+ }
+
+ addEvent(eventName, params);
+ addQueryStringValue("measurement_id", MEASUREMENT_ID);
+ addQueryStringValue("api_secret", API_SECRET);
+ addQueryStringValue("_geo", "1");
+ addQueryStringValue("ep.anonymize_ip", "false");
+ addJsonValue("client_id", CLIENT_ID);
+ addJsonValues("events", Event.toObjectList(events));
+ StringBuilder urlSb = new StringBuilder();
+ urlSb.append(BASE_URL);
+ urlSb.append('?');
+ urlSb.append(buildQueryString());
try
{
- URL url = new URL(sb.toString());
+ URL url = new URL(urlSb.toString());
URLConnection urlConnection = url.openConnection();
HttpURLConnection httpURLConnection = (HttpURLConnection) urlConnection;
httpURLConnection.setRequestMethod("POST");
httpURLConnection.setDoOutput(true);
- byte[] jsonBytes = buildJson().getBytes(StandardCharsets.UTF_8);
+ String jsonString = buildJson();
+
+ Console.debug("GA4: HTTP Request is: '" + urlSb.toString() + "'");
+ Console.debug("GA4: POSTed JSON is:\n" + jsonString);
+
+ byte[] jsonBytes = jsonString.getBytes(StandardCharsets.UTF_8);
int jsonLength = jsonBytes.length;
httpURLConnection.setFixedLengthStreamingMode(jsonLength);
{
os.write(jsonBytes);
}
+ int responseCode = httpURLConnection.getResponseCode();
+ String responseMessage = httpURLConnection.getResponseMessage();
+ if (responseCode < 200 || responseCode > 299)
+ {
+ Console.warn("GoogleAnalytics4 connection failed: '" + responseCode
+ + " " + responseMessage + "'");
+ }
+ else
+ {
+ Console.debug("GoogleAnalytics4 connection succeeded: '"
+ + responseCode + " " + responseMessage + "'");
+ }
+
+ if (DEBUG)
+ {
+ BufferedReader br = new BufferedReader(new InputStreamReader(
+ (httpURLConnection.getInputStream())));
+ StringBuilder sb = new StringBuilder();
+ String response;
+ while ((response = br.readLine()) != null)
+ {
+ sb.append(response);
+ }
+ String body = sb.toString();
+ Console.debug("GoogleAnalytics4 response content; " + body);
+ }
} catch (MalformedURLException e)
{
Console.debug(
- "Somehow the GoogleAnalytics4 BASE_URL and queryString is malformed.",
+ "Somehow the GoogleAnalytics4 BASE_URL and queryString is malformed: '"
+ + urlSb.toString() + "'",
e);
return;
} catch (IOException e)
"Couldn't cast URLConnection to HttpURLConnection in GoogleAnalytics4.",
e);
}
+ }
+
+ public void addEvent(String name, Map<String, String> params)
+ {
+ Event event = new Event(name);
+ if (params != null && params.size() > 0)
+ {
+ for (String key : params.keySet())
+ {
+ String value = params.get(key);
+ event.addParam(key, value);
+ }
+ }
+ events.add(event);
+ }
+ private void addJsonObject(String key,
+ List<Map.Entry<String, Object>> object)
+ {
+ jsonObject.add(objectEntry(key, object));
}
- private void addToJson(String key, List<Object> values)
+ private void addJsonValues(String key, List<Object> values)
{
- jsonValues.add(jsonEntry(key, values));
+ jsonObject.add(objectEntry(key, values));
}
- private void addToJson(String key, String value)
+ private void addJsonValue(String key, String value)
{
- jsonValues.add(jsonEntry(key, value));
+ jsonObject.add(objectEntry(key, value));
}
- private void addToJson(String key, int value)
+ private void addJsonValue(String key, int value)
{
- jsonValues.add(jsonEntry(key, Integer.valueOf(value)));
+ jsonObject.add(objectEntry(key, Integer.valueOf(value)));
}
- private void addToJson(String key, boolean value)
+ private void addJsonValue(String key, boolean value)
{
- jsonValues.add(jsonEntry(key, Boolean.valueOf(value)));
+ jsonObject.add(objectEntry(key, Boolean.valueOf(value)));
}
private void addQueryStringValue(String key, String value)
{
- queryStringValues.add(qsEntry(key, value));
+ queryStringValues.add(stringEntry(key, value));
}
private void addCookieValue(String key, String value)
{
- cookieValues.add(qsEntry(key, value));
+ cookieValues.add(stringEntry(key, value));
}
- public void reset()
+ private void resetLists()
{
- jsonValues = new ArrayList<>();
+ jsonObject = new ArrayList<>();
+ events = new ArrayList<Event>();
queryStringValues = new ArrayList<>();
cookieValues = new ArrayList<>();
}
+ public static GoogleAnalytics4 getInstance()
+ {
+ if (instance == null)
+ {
+ instance = new GoogleAnalytics4();
+ }
+ return instance;
+ }
+
+ public static void reset()
+ {
+ getInstance().resetLists();
+ }
+
private String buildQueryString()
{
StringBuilder sb = new StringBuilder();
{
sb.append('&');
}
- sb.append(URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8));
+ try
+ {
+ sb.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
+ } catch (UnsupportedEncodingException e)
+ {
+ sb.append(entry.getKey());
+ }
sb.append('=');
- sb.append(
- URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8));
+ try
+ {
+ sb.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
+ } catch (UnsupportedEncodingException e)
+ {
+ sb.append(entry.getValue());
+ }
}
return sb.toString();
}
private String buildJson()
{
StringBuilder sb = new StringBuilder();
- int indent = 0;
- sb.append("{");
- for (Map.Entry<String, Object> entry : jsonValues)
- {
-
- }
- sb.append("}");
+ addJsonObject(sb, 0, jsonObject);
return sb.toString();
}
private void addJsonObject(StringBuilder sb, int indent,
- Map.Entry<String, Object> entry)
+ List<Map.Entry<String, Object>> entries)
{
- String key = entry.getKey();
- Object value = entry.getValue();
indent(sb, indent);
- sb.append('"').append(key).append('"');
- sb.append(": ");
- if (List.class.equals(value.getClass()))
+ sb.append('{');
+ newline(sb);
+ Iterator<Map.Entry<String, Object>> entriesI = entries.iterator();
+ while (entriesI.hasNext())
{
- sb.append('\n');
+ Map.Entry<String, Object> entry = entriesI.next();
+ String key = entry.getKey();
+ // TODO sensibly escape " characters in key
+ Object value = entry.getValue();
+ indent(sb, indent + 1);
+ sb.append('"').append(quoteEscape(key)).append('"').append(':');
+ space(sb);
+ if (value != null && value instanceof List)
+ {
+ newline(sb);
+ }
+ addJsonValue(sb, indent + 2, value);
+ if (entriesI.hasNext())
+ {
+ sb.append(',');
+ }
+ newline(sb);
}
- addJsonValue(sb, indent, value);
- sb.append(",\n");
+ indent(sb, indent);
+ sb.append('}');
}
private void addJsonValue(StringBuilder sb, int indent, Object value)
}
try
{
- Class<? extends Object> c = value.getClass();
- if (Map.Entry.class.equals(c))
+ if (value instanceof Map.Entry)
{
- Map.Entry<String, Object> object = (Map.Entry<String, Object>) value;
- addJsonObject(sb, indent + 1, object);
+ Map.Entry<String, Object> entry = (Map.Entry<String, Object>) value;
+ List<Map.Entry<String, Object>> object = new ArrayList<>();
+ object.add(entry);
+ addJsonObject(sb, indent, object);
}
- else if (List.class.equals(c))
+ else if (value instanceof List)
{
- indent(sb, indent);
- sb.append("[\n");
- for (Object v : (List<Object>) value)
+ // list of Map.Entries or list of values?
+ List<Object> valueList = (List<Object>) value;
+ if (valueList.size() > 0 && valueList.get(0) instanceof Map.Entry)
{
- indent(sb, indent + 1);
- addJsonValue(sb, indent, v);
- sb.append(",\n");
+ // entries
+ // indent(sb, indent);
+ List<Map.Entry<String, Object>> entryList = (List<Map.Entry<String, Object>>) value;
+ addJsonObject(sb, indent, entryList);
+ }
+ else
+ {
+ // values
+ indent(sb, indent);
+ sb.append('[');
+ newline(sb);
+ Iterator<Object> valueListI = valueList.iterator();
+ while (valueListI.hasNext())
+ {
+ Object v = valueListI.next();
+ addJsonValue(sb, indent + 1, v);
+ if (valueListI.hasNext())
+ {
+ sb.append(',');
+ }
+ newline(sb);
+ }
+ indent(sb, indent);
+ sb.append("]");
}
- indent(sb, indent);
- sb.append("]");
}
- else if (String.class.equals(c))
+ else if (value instanceof String)
{
- sb.append('"');
- sb.append((String) value);
- sb.append('"');
+ sb.append('"').append(quoteEscape((String) value)).append('"');
}
- else if (Integer.class.equals(c))
+ else if (value instanceof Integer)
{
sb.append(((Integer) value).toString());
}
- else if (Boolean.class.equals(c))
+ else if (value instanceof Boolean)
{
- sb.append(((Boolean) value).toString());
+ sb.append('"').append(((Boolean) value).toString()).append('"');
}
} catch (ClassCastException e)
{
Console.debug(
- "Could not deal with type of jsonObject " + value.toString(),
+ "Could not deal with type of json Object " + value.toString(),
e);
}
}
- private void indent(StringBuilder sb, int indent)
+ private static String quoteEscape(String s)
+ {
+ if (s == null)
+ {
+ return null;
+ }
+ // this escapes quotation marks (") that aren't already escaped (in the
+ // string) ready to go into a quoted JSON string value
+ return s.replaceAll("((?<!\\\\)(?:\\\\{2})*)\"", "$1\\\\\"");
+ }
+
+ private static void prettyWhitespace(StringBuilder sb, String whitespace,
+ int repeat)
+ {
+ // only add whitespace if we're in DEBUG mode
+ if (!Console.getLogger().isDebugEnabled())
+ {
+ return;
+ }
+ if (repeat >= 0 && whitespace != null)
+ {
+ // sb.append(whitespace.repeat(repeat));
+ sb.append(String.join("", Collections.nCopies(repeat, whitespace)));
+
+ }
+ else
+ {
+ sb.append(whitespace);
+ }
+ }
+
+ private static void indent(StringBuilder sb, int indent)
+ {
+ prettyWhitespace(sb, " ", indent);
+ }
+
+ private static void newline(StringBuilder sb)
+ {
+ prettyWhitespace(sb, "\n", -1);
+ }
+
+ private static void space(StringBuilder sb)
{
- sb.append(" ".repeat(indent));
+ prettyWhitespace(sb, " ", -1);
}
- private static Map.Entry<String, Object> jsonEntry(String s, Object o)
+ protected static Map.Entry<String, Object> objectEntry(String s, Object o)
{
return new AbstractMap.SimpleEntry<String, Object>(s, o);
}
- private static Map.Entry<String, String> qsEntry(String s, String v)
+ protected static Map.Entry<String, String> stringEntry(String s, String v)
{
return new AbstractMap.SimpleEntry<String, String>(s, v);
}
}
+
+class Event
+{
+ private String name;
+
+ private List<Map.Entry<String, String>> params;
+
+ @SafeVarargs
+ public Event(String name, Map.Entry<String, String>... paramEntries)
+ {
+ this.name = name;
+ this.params = new ArrayList<Map.Entry<String, String>>();
+ for (Map.Entry<String, String> paramEntry : paramEntries)
+ {
+ if (paramEntry == null)
+ {
+ continue;
+ }
+ params.add(paramEntry);
+ }
+ }
+
+ public void addParam(String param, String value)
+ {
+ params.add(GoogleAnalytics4.stringEntry(param, value));
+ }
+
+ protected List<Map.Entry<String, Object>> toObject()
+ {
+ List<Map.Entry<String, Object>> object = new ArrayList<>();
+ object.add(GoogleAnalytics4.objectEntry("name", (Object) name));
+ if (params.size() > 0)
+ {
+ object.add(GoogleAnalytics4.objectEntry("params", (Object) params));
+ }
+ return object;
+ }
+
+ protected static List<Object> toObjectList(List<Event> events)
+ {
+ List<Object> eventObjectList = new ArrayList<>();
+ for (Event event : events)
+ {
+ eventObjectList.add((Object) event.toObject());
+ }
+ return eventObjectList;
+ }
+}
git://source.jalview.org / jalview.git / blobdiff