1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
// FxA Telemetry support. For hysterical raisins, the actual implementation
// is inside "sync". We should move the core implementation somewhere that's
// sanely shared (eg, services-common?), but let's wait and see where we end up
// first...
import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
const lazy = {};
ChromeUtils.defineESModuleGetters(lazy, {
CryptoUtils: "resource://services-crypto/utils.sys.mjs",
// We use this observers module because we leverage its support for richer
// "subject" data.
Observers: "resource://services-common/observers.sys.mjs",
});
import {
PREF_ACCOUNT_ROOT,
log,
} from "resource://gre/modules/FxAccountsCommon.sys.mjs";
const PREF_SANITIZED_UID = PREF_ACCOUNT_ROOT + "telemetry.sanitized_uid";
XPCOMUtils.defineLazyPreferenceGetter(
lazy,
"pref_sanitizedUid",
PREF_SANITIZED_UID,
""
);
export class FxAccountsTelemetry {
constructor(fxai) {
this._fxai = fxai;
Services.telemetry.setEventRecordingEnabled("fxa", true);
}
// Records an event *in the Fxa/Sync ping*.
recordEvent(object, method, value, extra = undefined) {
// We need to ensure the telemetry module is loaded.
ChromeUtils.importESModule("resource://services-sync/telemetry.sys.mjs");
// Now it will be listening for the notifications...
lazy.Observers.notify("fxa:telemetry:event", {
object,
method,
value,
extra,
});
}
generateUUID() {
return Services.uuid.generateUUID().toString().slice(1, -1);
}
// A flow ID can be anything that's "probably" unique, so for now use a UUID.
generateFlowID() {
return this.generateUUID();
}
// FxA- and Sync-related metrics are submitted in a special-purpose "sync ping". This ping
// identifies the user by a version of their FxA uid that is HMAC-ed with a server-side secret
// key, in an attempt to provide a bit of anonymity.
// Secret back-channel by which tokenserver client code can set the hashed UID.
// This value conceptually belongs to FxA, but we currently get it from tokenserver,
// so there's some light hackery to put it in the right place.
_setHashedUID(hashedUID) {
if (!hashedUID) {
Services.prefs.clearUserPref(PREF_SANITIZED_UID);
} else {
Services.prefs.setStringPref(PREF_SANITIZED_UID, hashedUID);
}
}
getSanitizedUID() {
// Sadly, we can only currently obtain this value if the user has enabled sync.
return lazy.pref_sanitizedUid || null;
}
// Sanitize the ID of a device into something suitable for including in the
// ping. Returns null if no transformation is possible.
sanitizeDeviceId(deviceId) {
const uid = this.getSanitizedUID();
if (!uid) {
// Sadly, we can only currently get this if the user has enabled sync.
return null;
}
// Combine the raw device id with the sanitized uid to create a stable
// unique identifier that can't be mapped back to the user's FxA
// identity without knowing the metrics HMAC key.
// The result is 64 bytes long, which in retrospect is probably excessive,
// but it's already shipping...
return lazy.CryptoUtils.sha256(deviceId + uid);
}
// Record the connection of FxA or one of its services.
// Note that you must call this before performing the actual connection
// or we may record incorrect data - for example, we will not be able to
// determine whether FxA itself was connected before this call.
//
// Currently sends an event in the main telemetry event ping rather than the
// FxA/Sync ping (although this might change in the future)
//
// @param services - An array of service names which should be recorded. FxA
// itself is not counted as a "service" - ie, an empty array should be passed
// if the account is connected without anything else .
//
// @param how - How the connection was done.
async recordConnection(services, how = null) {
try {
let extra = {};
// Record that fxa was connected if it isn't currently - it will be soon.
if (!(await this._fxai.getUserAccountData())) {
extra.fxa = "true";
}
// Events.yaml only declares "sync" as a valid service.
if (services.includes("sync")) {
extra.sync = "true";
}
Services.telemetry.recordEvent("fxa", "connect", "account", how, extra);
} catch (ex) {
log.error("Failed to record connection telemetry", ex);
console.error("Failed to record connection telemetry", ex);
}
}
// Record the disconnection of FxA or one of its services.
// Note that you must call this before performing the actual disconnection
// or we may record incomplete data - for example, if this is called after
// disconnection, we've almost certainly lost the ability to record what
// services were enabled prior to disconnection.
//
// Currently sends an event in the main telemetry event ping rather than the
// FxA/Sync ping (although this might change in the future)
//
// @param service - the service being disconnected. If null, the account
// itself is being disconnected, so all connected services are too.
//
// @param how - how the disconnection was done.
async recordDisconnection(service = null, how = null) {
try {
let extra = {};
if (!service) {
extra.fxa = "true";
// We need a way to enumerate all services - but for now we just hard-code
// all possibilities here.
if (Services.prefs.prefHasUserValue("services.sync.username")) {
extra.sync = "true";
}
} else if (service == "sync") {
extra[service] = "true";
} else {
// Events.yaml only declares "sync" as a valid service.
log.warn(
`recordDisconnection has invalid value for service: ${service}`
);
}
Services.telemetry.recordEvent(
"fxa",
"disconnect",
"account",
how,
extra
);
} catch (ex) {
log.error("Failed to record disconnection telemetry", ex);
console.error("Failed to record disconnection telemetry", ex);
}
}
}
|
