976 lines
29 KiB
TypeScript
976 lines
29 KiB
TypeScript
/*
|
|
Copyright 2020 The Matrix.org Foundation C.I.C.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
import { randomString } from "matrix-js-sdk/src/randomstring";
|
|
import { IContent } from "matrix-js-sdk/src/models/event";
|
|
import { sleep } from "matrix-js-sdk/src/utils";
|
|
|
|
import { getCurrentLanguage } from './languageHandler';
|
|
import PlatformPeg from './PlatformPeg';
|
|
import SdkConfig from './SdkConfig';
|
|
import { MatrixClientPeg } from "./MatrixClientPeg";
|
|
import RoomViewStore from "./stores/RoomViewStore";
|
|
import { Action } from "./dispatcher/actions";
|
|
|
|
import { logger } from "matrix-js-sdk/src/logger";
|
|
|
|
const INACTIVITY_TIME = 20; // seconds
|
|
const HEARTBEAT_INTERVAL = 5_000; // ms
|
|
const SESSION_UPDATE_INTERVAL = 60; // seconds
|
|
const MAX_PENDING_EVENTS = 1000;
|
|
|
|
export type Rating = 1 | 2 | 3 | 4 | 5;
|
|
|
|
enum Orientation {
|
|
Landscape = "landscape",
|
|
Portrait = "portrait",
|
|
}
|
|
|
|
/* eslint-disable camelcase */
|
|
interface IMetrics {
|
|
_resolution?: string;
|
|
_app_version?: string;
|
|
_density?: number;
|
|
_ua?: string;
|
|
_locale?: string;
|
|
}
|
|
|
|
interface IEvent {
|
|
key: string;
|
|
count: number;
|
|
sum?: number;
|
|
dur?: number;
|
|
segmentation?: Record<string, unknown>;
|
|
timestamp?: number; // TODO should we use the timestamp when we start or end for the event timestamp
|
|
hour?: unknown;
|
|
dow?: unknown;
|
|
}
|
|
|
|
interface IViewEvent extends IEvent {
|
|
key: "[CLY]_view";
|
|
}
|
|
|
|
interface IOrientationEvent extends IEvent {
|
|
key: "[CLY]_orientation";
|
|
segmentation: {
|
|
mode: Orientation;
|
|
};
|
|
}
|
|
|
|
interface IStarRatingEvent extends IEvent {
|
|
key: "[CLY]_star_rating";
|
|
segmentation: {
|
|
// we just care about collecting feedback, no need to associate with a feedback widget
|
|
widget_id?: string;
|
|
contactMe?: boolean;
|
|
email?: string;
|
|
rating: 1 | 2 | 3 | 4 | 5;
|
|
comment: string;
|
|
};
|
|
}
|
|
|
|
type Value = string | number | boolean;
|
|
|
|
interface IOperationInc {
|
|
"$inc": number;
|
|
}
|
|
interface IOperationMul {
|
|
"$mul": number;
|
|
}
|
|
interface IOperationMax {
|
|
"$max": number;
|
|
}
|
|
interface IOperationMin {
|
|
"$min": number;
|
|
}
|
|
interface IOperationSetOnce {
|
|
"$setOnce": Value;
|
|
}
|
|
interface IOperationPush {
|
|
"$push": Value | Value[];
|
|
}
|
|
interface IOperationAddToSet {
|
|
"$addToSet": Value | Value[];
|
|
}
|
|
interface IOperationPull {
|
|
"$pull": Value | Value[];
|
|
}
|
|
|
|
type Operation =
|
|
IOperationInc |
|
|
IOperationMul |
|
|
IOperationMax |
|
|
IOperationMin |
|
|
IOperationSetOnce |
|
|
IOperationPush |
|
|
IOperationAddToSet |
|
|
IOperationPull;
|
|
|
|
interface IUserDetails {
|
|
name?: string;
|
|
username?: string;
|
|
email?: string;
|
|
organization?: string;
|
|
phone?: string;
|
|
picture?: string;
|
|
gender?: string;
|
|
byear?: number;
|
|
custom?: Record<string, Value | Operation>; // `.` and `$` will be stripped out
|
|
}
|
|
|
|
interface ICrash {
|
|
_resolution?: string;
|
|
_app_version: string;
|
|
|
|
_ram_current?: number;
|
|
_ram_total?: number;
|
|
_disk_current?: number;
|
|
_disk_total?: number;
|
|
_orientation?: Orientation;
|
|
|
|
_online?: boolean;
|
|
_muted?: boolean;
|
|
_background?: boolean;
|
|
_view?: string;
|
|
|
|
_name?: string;
|
|
_error: string;
|
|
_nonfatal?: boolean;
|
|
_logs?: string;
|
|
_run?: number;
|
|
|
|
_custom?: Record<string, string>;
|
|
}
|
|
|
|
interface IParams {
|
|
// APP_KEY of an app for which to report
|
|
app_key: string;
|
|
// User identifier
|
|
device_id: string;
|
|
|
|
// Should provide value 1 to indicate session start
|
|
begin_session?: number;
|
|
// JSON object as string to provide metrics to track with the user
|
|
metrics?: string;
|
|
// Provides session duration in seconds, can be used as heartbeat to update current sessions duration, recommended time every 60 seconds
|
|
session_duration?: number;
|
|
// Should provide value 1 to indicate session end
|
|
end_session?: number;
|
|
|
|
// 10 digit UTC timestamp for recording past data.
|
|
timestamp?: number;
|
|
// current user local hour (0 - 23)
|
|
hour?: number;
|
|
// day of the week (0-sunday, 1 - monday, ... 6 - saturday)
|
|
dow?: number;
|
|
|
|
// JSON array as string containing event objects
|
|
events?: string; // IEvent[]
|
|
// JSON object as string containing information about users
|
|
user_details?: string;
|
|
|
|
// provide when changing device ID, so server would merge the data
|
|
old_device_id?: string;
|
|
|
|
// See ICrash
|
|
crash?: string;
|
|
}
|
|
|
|
interface IRoomSegments extends Record<string, Value> {
|
|
room_id: string; // hashed
|
|
num_users: number;
|
|
is_encrypted: boolean;
|
|
is_public: boolean;
|
|
}
|
|
|
|
interface ISendMessageEvent extends IEvent {
|
|
key: "send_message";
|
|
dur: number; // how long it to send (until remote echo)
|
|
segmentation: IRoomSegments & {
|
|
is_edit: boolean;
|
|
is_reply: boolean;
|
|
msgtype: string;
|
|
format?: string;
|
|
};
|
|
}
|
|
|
|
interface IRoomDirectoryEvent extends IEvent {
|
|
key: "room_directory";
|
|
}
|
|
|
|
interface IRoomDirectoryDoneEvent extends IEvent {
|
|
key: "room_directory_done";
|
|
dur: number; // time spent in the room directory modal
|
|
}
|
|
|
|
interface IRoomDirectorySearchEvent extends IEvent {
|
|
key: "room_directory_search";
|
|
sum: number; // number of search results
|
|
segmentation: {
|
|
query_length: number;
|
|
query_num_words: number;
|
|
};
|
|
}
|
|
|
|
interface IStartCallEvent extends IEvent {
|
|
key: "start_call";
|
|
segmentation: IRoomSegments & {
|
|
is_video: boolean;
|
|
is_jitsi: boolean;
|
|
};
|
|
}
|
|
|
|
interface IJoinCallEvent extends IEvent {
|
|
key: "join_call";
|
|
segmentation: IRoomSegments & {
|
|
is_video: boolean;
|
|
is_jitsi: boolean;
|
|
};
|
|
}
|
|
|
|
interface IBeginInviteEvent extends IEvent {
|
|
key: "begin_invite";
|
|
segmentation: IRoomSegments;
|
|
}
|
|
|
|
interface ISendInviteEvent extends IEvent {
|
|
key: "send_invite";
|
|
sum: number; // quantity that was invited
|
|
segmentation: IRoomSegments;
|
|
}
|
|
|
|
interface ICreateRoomEvent extends IEvent {
|
|
key: "create_room";
|
|
dur: number; // how long it took to create (until remote echo)
|
|
segmentation: {
|
|
room_id: string; // hashed
|
|
num_users: number;
|
|
is_encrypted: boolean;
|
|
is_public: boolean;
|
|
};
|
|
}
|
|
|
|
interface IJoinRoomEvent extends IEvent {
|
|
key: Action.JoinRoom;
|
|
dur: number; // how long it took to join (until remote echo)
|
|
segmentation: {
|
|
room_id: string; // hashed
|
|
num_users: number;
|
|
is_encrypted: boolean;
|
|
is_public: boolean;
|
|
type: "room_directory" | "slash_command" | "link" | "invite";
|
|
};
|
|
}
|
|
/* eslint-enable camelcase */
|
|
|
|
const hashHex = async (input: string): Promise<string> => {
|
|
const buf = new TextEncoder().encode(input);
|
|
const digestBuf = await window.crypto.subtle.digest("sha-256", buf);
|
|
return [...new Uint8Array(digestBuf)].map((b: number) => b.toString(16).padStart(2, "0")).join("");
|
|
};
|
|
|
|
const knownScreens = new Set([
|
|
"register", "login", "forgot_password", "soft_logout", "new", "settings", "welcome", "home", "start", "directory",
|
|
"start_sso", "start_cas", "groups", "complete_security", "post_registration", "room", "user", "group",
|
|
]);
|
|
|
|
interface IViewData {
|
|
name: string;
|
|
url: string;
|
|
meta: Record<string, string>;
|
|
}
|
|
|
|
// Apply fn to all hash path parts after the 1st one
|
|
async function getViewData(anonymous = true): Promise<IViewData> {
|
|
const rand = randomString(8);
|
|
const { origin, hash } = window.location;
|
|
let { pathname } = window.location;
|
|
|
|
// Redact paths which could contain unexpected PII
|
|
if (origin.startsWith('file://')) {
|
|
pathname = `/<redacted_${rand}>/`; // XXX: inject rand because Count.ly doesn't like X->X transitions
|
|
}
|
|
|
|
let [_, screen, ...parts] = hash.split("/");
|
|
|
|
if (!knownScreens.has(screen)) {
|
|
screen = `<redacted_${rand}>`;
|
|
}
|
|
|
|
for (let i = 0; i < parts.length; i++) {
|
|
parts[i] = anonymous ? `<redacted_${rand}>` : await hashHex(parts[i]);
|
|
}
|
|
|
|
const hashStr = `${_}/${screen}/${parts.join("/")}`;
|
|
const url = origin + pathname + hashStr;
|
|
|
|
const meta = {};
|
|
|
|
let name = "$/" + hash;
|
|
switch (screen) {
|
|
case "room": {
|
|
name = "view_room";
|
|
const roomId = RoomViewStore.getRoomId();
|
|
name += " " + parts[0]; // XXX: workaround Count.ly missing X->X transitions
|
|
meta["room_id"] = parts[0];
|
|
Object.assign(meta, getRoomStats(roomId));
|
|
break;
|
|
}
|
|
}
|
|
|
|
return { name, url, meta };
|
|
}
|
|
|
|
const getRoomStats = (roomId: string) => {
|
|
const cli = MatrixClientPeg.get();
|
|
const room = cli?.getRoom(roomId);
|
|
|
|
return {
|
|
"num_users": room?.getJoinedMemberCount(),
|
|
"is_encrypted": cli?.isRoomEncrypted(roomId),
|
|
// eslint-disable-next-line camelcase
|
|
"is_public": room?.currentState.getStateEvents("m.room.join_rules", "")?.getContent()?.join_rule === "public",
|
|
};
|
|
};
|
|
|
|
// async wrapper for regex-powered String.prototype.replace
|
|
const strReplaceAsync = async (str: string, regex: RegExp, fn: (...args: string[]) => Promise<string>) => {
|
|
const promises: Promise<string>[] = [];
|
|
// dry-run to calculate the replace values
|
|
str.replace(regex, (...args: string[]) => {
|
|
promises.push(fn(...args));
|
|
return "";
|
|
});
|
|
const values = await Promise.all(promises);
|
|
return str.replace(regex, () => values.shift());
|
|
};
|
|
|
|
export default class CountlyAnalytics {
|
|
private baseUrl: URL = null;
|
|
private appKey: string = null;
|
|
private userKey: string = null;
|
|
private anonymous: boolean;
|
|
private appPlatform: string;
|
|
private appVersion = "unknown";
|
|
|
|
private initTime = CountlyAnalytics.getTimestamp();
|
|
private firstPage = true;
|
|
private heartbeatIntervalId: number;
|
|
private activityIntervalId: number;
|
|
private trackTime = true;
|
|
private lastBeat: number;
|
|
private storedDuration = 0;
|
|
private lastView: string;
|
|
private lastViewTime = 0;
|
|
private lastViewStoredDuration = 0;
|
|
private sessionStarted = false;
|
|
private heartbeatEnabled = false;
|
|
private inactivityCounter = 0;
|
|
private pendingEvents: IEvent[] = [];
|
|
|
|
private static internalInstance = new CountlyAnalytics();
|
|
|
|
public static get instance(): CountlyAnalytics {
|
|
return CountlyAnalytics.internalInstance;
|
|
}
|
|
|
|
public get disabled() {
|
|
return !this.baseUrl;
|
|
}
|
|
|
|
public canEnable() {
|
|
const config = SdkConfig.get();
|
|
return Boolean(navigator.doNotTrack !== "1" && config?.countly?.url && config?.countly?.appKey);
|
|
}
|
|
|
|
private async changeUserKey(userKey: string, merge = false) {
|
|
const oldUserKey = this.userKey;
|
|
this.userKey = userKey;
|
|
if (oldUserKey && merge) {
|
|
await this.request({ old_device_id: oldUserKey });
|
|
}
|
|
}
|
|
|
|
public async enable(anonymous = true) {
|
|
if (!this.disabled && this.anonymous === anonymous) return;
|
|
if (!this.canEnable()) return;
|
|
|
|
if (!this.disabled) {
|
|
// flush request queue as our userKey is going to change, no need to await it
|
|
this.request();
|
|
}
|
|
|
|
const config = SdkConfig.get();
|
|
this.baseUrl = new URL("/i", config.countly.url);
|
|
this.appKey = config.countly.appKey;
|
|
|
|
this.anonymous = anonymous;
|
|
if (anonymous) {
|
|
await this.changeUserKey(randomString(64));
|
|
} else {
|
|
await this.changeUserKey(await hashHex(MatrixClientPeg.get().getUserId()), true);
|
|
}
|
|
|
|
const platform = PlatformPeg.get();
|
|
this.appPlatform = platform.getHumanReadableName();
|
|
try {
|
|
this.appVersion = await platform.getAppVersion();
|
|
} catch (e) {
|
|
logger.warn("Failed to get app version, using 'unknown'");
|
|
}
|
|
|
|
// start heartbeat
|
|
this.heartbeatIntervalId = setInterval(this.heartbeat.bind(this), HEARTBEAT_INTERVAL);
|
|
this.trackSessions();
|
|
this.trackErrors();
|
|
}
|
|
|
|
public async disable() {
|
|
if (this.disabled) return;
|
|
await this.track("Opt-Out" );
|
|
this.endSession();
|
|
window.clearInterval(this.heartbeatIntervalId);
|
|
window.clearTimeout(this.activityIntervalId);
|
|
this.baseUrl = null;
|
|
// remove listeners bound in trackSessions()
|
|
window.removeEventListener("beforeunload", this.endSession);
|
|
window.removeEventListener("unload", this.endSession);
|
|
window.removeEventListener("visibilitychange", this.onVisibilityChange);
|
|
window.removeEventListener("mousemove", this.onUserActivity);
|
|
window.removeEventListener("click", this.onUserActivity);
|
|
window.removeEventListener("keydown", this.onUserActivity);
|
|
window.removeEventListener("scroll", this.onUserActivity);
|
|
}
|
|
|
|
public reportFeedback(rating: Rating, comment: string) {
|
|
this.track<IStarRatingEvent>("[CLY]_star_rating", { rating, comment }, null, {}, true);
|
|
}
|
|
|
|
public trackPageChange(generationTimeMs?: number) {
|
|
if (this.disabled) return;
|
|
// TODO use generationTimeMs
|
|
this.trackPageView();
|
|
}
|
|
|
|
private async trackPageView() {
|
|
this.reportViewDuration();
|
|
|
|
await sleep(0); // XXX: we sleep here because otherwise we get the old hash and not the new one
|
|
const viewData = await getViewData(this.anonymous);
|
|
|
|
const page = viewData.name;
|
|
this.lastView = page;
|
|
this.lastViewTime = CountlyAnalytics.getTimestamp();
|
|
const segments = {
|
|
...viewData.meta,
|
|
name: page,
|
|
visit: 1,
|
|
domain: window.location.hostname,
|
|
view: viewData.url,
|
|
segment: this.appPlatform,
|
|
start: this.firstPage,
|
|
};
|
|
|
|
if (this.firstPage) {
|
|
this.firstPage = false;
|
|
}
|
|
|
|
this.track<IViewEvent>("[CLY]_view", segments);
|
|
}
|
|
|
|
public static getTimestamp() {
|
|
return Math.floor(new Date().getTime() / 1000);
|
|
}
|
|
|
|
// store the last ms timestamp returned
|
|
// we do this to prevent the ts from ever decreasing in the case of system time changing
|
|
private lastMsTs = 0;
|
|
|
|
private getMsTimestamp() {
|
|
const ts = new Date().getTime();
|
|
if (this.lastMsTs >= ts) {
|
|
// increment ts as to keep our data points well-ordered
|
|
this.lastMsTs++;
|
|
} else {
|
|
this.lastMsTs = ts;
|
|
}
|
|
return this.lastMsTs;
|
|
}
|
|
|
|
public async recordError(err: Error | string, fatal = false) {
|
|
if (this.disabled || this.anonymous) return;
|
|
|
|
let error = "";
|
|
if (typeof err === "object") {
|
|
if (typeof err.stack !== "undefined") {
|
|
error = err.stack;
|
|
} else {
|
|
if (typeof err.name !== "undefined") {
|
|
error += err.name + ":";
|
|
}
|
|
if (typeof err.message !== "undefined") {
|
|
error += err.message + "\n";
|
|
}
|
|
if (typeof err.fileName !== "undefined") {
|
|
error += "in " + err.fileName + "\n";
|
|
}
|
|
if (typeof err.lineNumber !== "undefined") {
|
|
error += "on " + err.lineNumber;
|
|
}
|
|
if (typeof err.columnNumber !== "undefined") {
|
|
error += ":" + err.columnNumber;
|
|
}
|
|
}
|
|
} else {
|
|
error = err + "";
|
|
}
|
|
|
|
// sanitize the error from identifiers
|
|
error = await strReplaceAsync(error, /([!@+#]).+?:[\w:.]+/g, async (substring: string, glyph: string) => {
|
|
return glyph + (await hashHex(substring.substring(1)));
|
|
});
|
|
|
|
const metrics = this.getMetrics();
|
|
const ob: ICrash = {
|
|
_resolution: metrics?._resolution,
|
|
_error: error,
|
|
_app_version: this.appVersion,
|
|
_run: CountlyAnalytics.getTimestamp() - this.initTime,
|
|
_nonfatal: !fatal,
|
|
_view: this.lastView,
|
|
};
|
|
|
|
if (typeof navigator.onLine !== "undefined") {
|
|
ob._online = navigator.onLine;
|
|
}
|
|
|
|
ob._background = document.hasFocus();
|
|
|
|
this.request({ crash: JSON.stringify(ob) });
|
|
}
|
|
|
|
private trackErrors() {
|
|
//override global uncaught error handler
|
|
window.onerror = (msg, url, line, col, err) => {
|
|
if (typeof err !== "undefined") {
|
|
this.recordError(err, false);
|
|
} else {
|
|
let error = "";
|
|
if (typeof msg !== "undefined") {
|
|
error += msg + "\n";
|
|
}
|
|
if (typeof url !== "undefined") {
|
|
error += "at " + url;
|
|
}
|
|
if (typeof line !== "undefined") {
|
|
error += ":" + line;
|
|
}
|
|
if (typeof col !== "undefined") {
|
|
error += ":" + col;
|
|
}
|
|
error += "\n";
|
|
|
|
try {
|
|
const stack = [];
|
|
// eslint-disable-next-line no-caller
|
|
let f = arguments.callee.caller;
|
|
while (f) {
|
|
stack.push(f.name);
|
|
f = f.caller;
|
|
}
|
|
error += stack.join("\n");
|
|
} catch (ex) {
|
|
//silent error
|
|
}
|
|
this.recordError(error, false);
|
|
}
|
|
};
|
|
|
|
window.addEventListener('unhandledrejection', (event) => {
|
|
this.recordError(new Error(`Unhandled rejection (reason: ${event.reason?.stack || event.reason}).`), true);
|
|
});
|
|
}
|
|
|
|
private heartbeat() {
|
|
const args: Pick<IParams, "session_duration"> = {};
|
|
|
|
// extend session if needed
|
|
if (this.sessionStarted && this.trackTime) {
|
|
const last = CountlyAnalytics.getTimestamp();
|
|
if (last - this.lastBeat >= SESSION_UPDATE_INTERVAL) {
|
|
args.session_duration = last - this.lastBeat;
|
|
this.lastBeat = last;
|
|
}
|
|
}
|
|
|
|
// process event queue
|
|
if (this.pendingEvents.length > 0 || args.session_duration) {
|
|
this.request(args);
|
|
}
|
|
}
|
|
|
|
private async request(
|
|
args: Omit<IParams, "app_key" | "device_id" | "timestamp" | "hour" | "dow">
|
|
& Partial<Pick<IParams, "device_id">> = {},
|
|
) {
|
|
const request: IParams = {
|
|
app_key: this.appKey,
|
|
device_id: this.userKey,
|
|
...this.getTimeParams(),
|
|
...args,
|
|
};
|
|
|
|
if (this.pendingEvents.length > 0) {
|
|
const EVENT_BATCH_SIZE = 10;
|
|
const events = this.pendingEvents.splice(0, EVENT_BATCH_SIZE);
|
|
request.events = JSON.stringify(events);
|
|
}
|
|
|
|
const params = new URLSearchParams(request as {});
|
|
|
|
try {
|
|
await window.fetch(this.baseUrl.toString(), {
|
|
method: "POST",
|
|
mode: "no-cors",
|
|
cache: "no-cache",
|
|
redirect: "follow",
|
|
headers: {
|
|
"Content-Type": "application/x-www-form-urlencoded",
|
|
},
|
|
body: params,
|
|
});
|
|
} catch (e) {
|
|
logger.error("Analytics error: ", e);
|
|
}
|
|
}
|
|
|
|
private getTimeParams(): Pick<IParams, "timestamp" | "hour" | "dow"> {
|
|
const date = new Date();
|
|
return {
|
|
timestamp: this.getMsTimestamp(),
|
|
hour: date.getHours(),
|
|
dow: date.getDay(),
|
|
};
|
|
}
|
|
|
|
private queue(args: Omit<IEvent, "timestamp" | "hour" | "dow" | "count"> & Partial<Pick<IEvent, "count">>) {
|
|
const { count = 1, ...rest } = args;
|
|
const ev = {
|
|
...this.getTimeParams(),
|
|
...rest,
|
|
count,
|
|
platform: this.appPlatform,
|
|
app_version: this.appVersion,
|
|
};
|
|
|
|
this.pendingEvents.push(ev);
|
|
if (this.pendingEvents.length > MAX_PENDING_EVENTS) {
|
|
this.pendingEvents.shift();
|
|
}
|
|
}
|
|
|
|
private getOrientation = (): Orientation => {
|
|
return window.matchMedia("(orientation: landscape)").matches
|
|
? Orientation.Landscape
|
|
: Orientation.Portrait;
|
|
};
|
|
|
|
private reportOrientation = () => {
|
|
this.track<IOrientationEvent>("[CLY]_orientation", {
|
|
mode: this.getOrientation(),
|
|
});
|
|
};
|
|
|
|
private startTime() {
|
|
if (!this.trackTime) {
|
|
this.trackTime = true;
|
|
this.lastBeat = CountlyAnalytics.getTimestamp() - this.storedDuration;
|
|
this.lastViewTime = CountlyAnalytics.getTimestamp() - this.lastViewStoredDuration;
|
|
this.lastViewStoredDuration = 0;
|
|
}
|
|
}
|
|
|
|
private stopTime() {
|
|
if (this.trackTime) {
|
|
this.trackTime = false;
|
|
this.storedDuration = CountlyAnalytics.getTimestamp() - this.lastBeat;
|
|
this.lastViewStoredDuration = CountlyAnalytics.getTimestamp() - this.lastViewTime;
|
|
}
|
|
}
|
|
|
|
private getMetrics(): IMetrics {
|
|
if (this.anonymous) return undefined;
|
|
const metrics: IMetrics = {};
|
|
|
|
// getting app version
|
|
metrics._app_version = this.appVersion;
|
|
metrics._ua = navigator.userAgent;
|
|
|
|
// getting resolution
|
|
if (screen.width && screen.height) {
|
|
metrics._resolution = `${screen.width}x${screen.height}`;
|
|
}
|
|
|
|
// getting density ratio
|
|
if (window.devicePixelRatio) {
|
|
metrics._density = window.devicePixelRatio;
|
|
}
|
|
|
|
// getting locale
|
|
metrics._locale = getCurrentLanguage();
|
|
|
|
return metrics;
|
|
}
|
|
|
|
private async beginSession(heartbeat = true) {
|
|
if (!this.sessionStarted) {
|
|
this.reportOrientation();
|
|
window.addEventListener("resize", this.reportOrientation);
|
|
|
|
this.lastBeat = CountlyAnalytics.getTimestamp();
|
|
this.sessionStarted = true;
|
|
this.heartbeatEnabled = heartbeat;
|
|
|
|
const userDetails: IUserDetails = {
|
|
custom: {
|
|
"home_server": MatrixClientPeg.get() && MatrixClientPeg.getHomeserverName(), // TODO hash?
|
|
"anonymous": this.anonymous,
|
|
},
|
|
};
|
|
|
|
const request: Parameters<typeof CountlyAnalytics.prototype.request>[0] = {
|
|
begin_session: 1,
|
|
user_details: JSON.stringify(userDetails),
|
|
};
|
|
|
|
const metrics = this.getMetrics();
|
|
if (metrics) {
|
|
request.metrics = JSON.stringify(metrics);
|
|
}
|
|
|
|
await this.request(request);
|
|
}
|
|
}
|
|
|
|
private reportViewDuration() {
|
|
if (this.lastView) {
|
|
this.track<IViewEvent>("[CLY]_view", {
|
|
name: this.lastView,
|
|
}, null, {
|
|
dur: this.trackTime ? CountlyAnalytics.getTimestamp() - this.lastViewTime : this.lastViewStoredDuration,
|
|
});
|
|
this.lastView = null;
|
|
}
|
|
}
|
|
|
|
private endSession = () => {
|
|
if (this.sessionStarted) {
|
|
window.removeEventListener("resize", this.reportOrientation);
|
|
|
|
this.reportViewDuration();
|
|
this.request({
|
|
end_session: 1,
|
|
session_duration: CountlyAnalytics.getTimestamp() - this.lastBeat,
|
|
});
|
|
}
|
|
this.sessionStarted = false;
|
|
};
|
|
|
|
private onVisibilityChange = () => {
|
|
if (document.hidden) {
|
|
this.stopTime();
|
|
} else {
|
|
this.startTime();
|
|
}
|
|
};
|
|
|
|
private onUserActivity = () => {
|
|
if (this.inactivityCounter >= INACTIVITY_TIME) {
|
|
this.startTime();
|
|
}
|
|
this.inactivityCounter = 0;
|
|
};
|
|
|
|
private trackSessions() {
|
|
this.beginSession();
|
|
this.startTime();
|
|
|
|
window.addEventListener("beforeunload", this.endSession);
|
|
window.addEventListener("unload", this.endSession);
|
|
window.addEventListener("visibilitychange", this.onVisibilityChange);
|
|
window.addEventListener("mousemove", this.onUserActivity);
|
|
window.addEventListener("click", this.onUserActivity);
|
|
window.addEventListener("keydown", this.onUserActivity);
|
|
// Using the passive option to not block the main thread
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#improving_scrolling_performance_with_passive_listeners
|
|
window.addEventListener("scroll", this.onUserActivity, { passive: true });
|
|
|
|
this.activityIntervalId = setInterval(() => {
|
|
this.inactivityCounter++;
|
|
if (this.inactivityCounter >= INACTIVITY_TIME) {
|
|
this.stopTime();
|
|
}
|
|
}, 60_000);
|
|
}
|
|
|
|
public trackBeginInvite(roomId: string) {
|
|
this.track<IBeginInviteEvent>("begin_invite", {}, roomId);
|
|
}
|
|
|
|
public trackSendInvite(startTime: number, roomId: string, qty: number) {
|
|
this.track<ISendInviteEvent>("send_invite", {}, roomId, {
|
|
dur: CountlyAnalytics.getTimestamp() - startTime,
|
|
sum: qty,
|
|
});
|
|
}
|
|
|
|
public async trackRoomCreate(startTime: number, roomId: string) {
|
|
if (this.disabled) return;
|
|
|
|
let endTime = CountlyAnalytics.getTimestamp();
|
|
const cli = MatrixClientPeg.get();
|
|
if (!cli.getRoom(roomId)) {
|
|
await new Promise<void>(resolve => {
|
|
const handler = (room) => {
|
|
if (room.roomId === roomId) {
|
|
cli.off("Room", handler);
|
|
resolve();
|
|
}
|
|
};
|
|
cli.on("Room", handler);
|
|
});
|
|
endTime = CountlyAnalytics.getTimestamp();
|
|
}
|
|
|
|
this.track<ICreateRoomEvent>("create_room", {}, roomId, {
|
|
dur: endTime - startTime,
|
|
});
|
|
}
|
|
|
|
public trackRoomJoin(startTime: number, roomId: string, type: IJoinRoomEvent["segmentation"]["type"]) {
|
|
this.track<IJoinRoomEvent>(Action.JoinRoom, { type }, roomId, {
|
|
dur: CountlyAnalytics.getTimestamp() - startTime,
|
|
});
|
|
}
|
|
|
|
public async trackSendMessage(
|
|
startTime: number,
|
|
// eslint-disable-next-line camelcase
|
|
sendPromise: Promise<{event_id: string}>,
|
|
roomId: string,
|
|
isEdit: boolean,
|
|
isReply: boolean,
|
|
content: IContent,
|
|
) {
|
|
if (this.disabled) return;
|
|
const cli = MatrixClientPeg.get();
|
|
const room = cli.getRoom(roomId);
|
|
|
|
const eventId = (await sendPromise).event_id;
|
|
let endTime = CountlyAnalytics.getTimestamp();
|
|
|
|
if (!room.findEventById(eventId)) {
|
|
await new Promise<void>(resolve => {
|
|
const handler = (ev) => {
|
|
if (ev.getId() === eventId) {
|
|
room.off("Room.localEchoUpdated", handler);
|
|
resolve();
|
|
}
|
|
};
|
|
|
|
room.on("Room.localEchoUpdated", handler);
|
|
});
|
|
endTime = CountlyAnalytics.getTimestamp();
|
|
}
|
|
|
|
this.track<ISendMessageEvent>("send_message", {
|
|
is_edit: isEdit,
|
|
is_reply: isReply,
|
|
msgtype: content.msgtype,
|
|
format: content.format,
|
|
}, roomId, {
|
|
dur: endTime - startTime,
|
|
});
|
|
}
|
|
|
|
public trackStartCall(roomId: string, isVideo = false, isJitsi = false) {
|
|
this.track<IStartCallEvent>("start_call", {
|
|
is_video: isVideo,
|
|
is_jitsi: isJitsi,
|
|
}, roomId);
|
|
}
|
|
|
|
public trackJoinCall(roomId: string, isVideo = false, isJitsi = false) {
|
|
this.track<IJoinCallEvent>("join_call", {
|
|
is_video: isVideo,
|
|
is_jitsi: isJitsi,
|
|
}, roomId);
|
|
}
|
|
|
|
public trackRoomDirectoryBegin() {
|
|
this.track<IRoomDirectoryEvent>("room_directory");
|
|
}
|
|
|
|
public trackRoomDirectory(startTime: number) {
|
|
this.track<IRoomDirectoryDoneEvent>("room_directory_done", {}, null, {
|
|
dur: CountlyAnalytics.getTimestamp() - startTime,
|
|
});
|
|
}
|
|
|
|
public trackRoomDirectorySearch(numResults: number, query: string) {
|
|
this.track<IRoomDirectorySearchEvent>("room_directory_search", {
|
|
query_length: query.length,
|
|
query_num_words: query.split(" ").length,
|
|
}, null, {
|
|
sum: numResults,
|
|
});
|
|
}
|
|
|
|
public async track<E extends IEvent>(
|
|
key: E["key"],
|
|
segments?: Omit<E["segmentation"], "room_id" | "num_users" | "is_encrypted" | "is_public">,
|
|
roomId?: string,
|
|
args?: Partial<Pick<E, "dur" | "sum" | "timestamp">>,
|
|
anonymous = false,
|
|
) {
|
|
if (this.disabled && !anonymous) return;
|
|
|
|
let segmentation = segments || {};
|
|
|
|
if (roomId) {
|
|
segmentation = {
|
|
room_id: await hashHex(roomId),
|
|
...getRoomStats(roomId),
|
|
...segments,
|
|
};
|
|
}
|
|
|
|
this.queue({
|
|
key,
|
|
count: 1,
|
|
segmentation,
|
|
...args,
|
|
});
|
|
|
|
// if this event can be sent anonymously and we are disabled then dispatch it right away
|
|
if (this.disabled && anonymous) {
|
|
await this.request({ device_id: randomString(64) });
|
|
}
|
|
}
|
|
}
|
|
|
|
// expose on window for easy access from the console
|
|
window.mxCountlyAnalytics = CountlyAnalytics;
|