1814 lines
56 KiB
JavaScript
1814 lines
56 KiB
JavaScript
// We're using console.error() to debug, so we'll be keeping this rule handy
|
||
/* eslint no-console: ["error", { allow: ["error"] }] */
|
||
|
||
/* 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/. */
|
||
|
||
// We use importESModule here instead of static import so that the Karma test
|
||
// environment won't choke on these module. This is because the Karma test
|
||
// environment already stubs out XPCOMUtils, AppConstants and RemoteSettings,
|
||
// and overrides importESModule to be a no-op (which can't be done for a static
|
||
// import statement).
|
||
|
||
// eslint-disable-next-line mozilla/use-static-import
|
||
const { XPCOMUtils } = ChromeUtils.importESModule(
|
||
"resource://gre/modules/XPCOMUtils.sys.mjs"
|
||
);
|
||
|
||
import {
|
||
actionTypes as at,
|
||
actionUtils as au,
|
||
} from "resource://newtab/common/Actions.mjs";
|
||
import { Prefs } from "resource://newtab/lib/ActivityStreamPrefs.sys.mjs";
|
||
import { classifySite } from "resource://newtab/lib/SiteClassifier.sys.mjs";
|
||
|
||
const lazy = {};
|
||
|
||
ChromeUtils.defineESModuleGetters(lazy, {
|
||
AboutNewTab: "resource:///modules/AboutNewTab.sys.mjs",
|
||
ClientEnvironmentBase:
|
||
"resource://gre/modules/components-utils/ClientEnvironment.sys.mjs",
|
||
ClientID: "resource://gre/modules/ClientID.sys.mjs",
|
||
ContextId: "moz-src:///browser/modules/ContextId.sys.mjs",
|
||
ExtensionSettingsStore:
|
||
"resource://gre/modules/ExtensionSettingsStore.sys.mjs",
|
||
HomePage: "resource:///modules/HomePage.sys.mjs",
|
||
Region: "resource://gre/modules/Region.sys.mjs",
|
||
TelemetryEnvironment: "resource://gre/modules/TelemetryEnvironment.sys.mjs",
|
||
UTEventReporting: "resource://newtab/lib/UTEventReporting.sys.mjs",
|
||
NewTabContentPing: "resource://newtab/lib/NewTabContentPing.sys.mjs",
|
||
NewTabUtils: "resource://gre/modules/NewTabUtils.sys.mjs",
|
||
NimbusFeatures: "resource://nimbus/ExperimentAPI.sys.mjs",
|
||
pktApi: "chrome://pocket/content/pktApi.sys.mjs",
|
||
});
|
||
|
||
XPCOMUtils.defineLazyPreferenceGetter(
|
||
lazy,
|
||
"handoffToAwesomebarPrefValue",
|
||
"browser.newtabpage.activity-stream.improvesearch.handoffToAwesomebar",
|
||
false,
|
||
(preference, previousValue, new_value) =>
|
||
Glean.newtabHandoffPreference.enabled.set(new_value)
|
||
);
|
||
|
||
export const PREF_IMPRESSION_ID = "impressionId";
|
||
export const TELEMETRY_PREF = "telemetry";
|
||
export const EVENTS_TELEMETRY_PREF = "telemetry.ut.events";
|
||
export const PREF_UNIFIED_ADS_SPOCS_ENABLED = "unifiedAds.spocs.enabled";
|
||
export const PREF_UNIFIED_ADS_TILES_ENABLED = "unifiedAds.tiles.enabled";
|
||
const PREF_ENDPOINTS = "discoverystream.endpoints";
|
||
const PREF_SHOW_SPONSORED_STORIES = "showSponsored";
|
||
const PREF_SHOW_SPONSORED_TOPSITES = "showSponsoredTopSites";
|
||
const BLANK_HOMEPAGE_URL = "chrome://browser/content/blanktab.html";
|
||
const PREF_PRIVATE_PING_ENABLED = "telemetry.privatePing.enabled";
|
||
const PREF_REDACT_NEWTAB_PING_NEABLED =
|
||
"telemetry.privatePing.redactNewtabPing.enabled";
|
||
const PREF_PRIVATE_PING_INFERRED_ENABLED =
|
||
"telemetry.privatePing.inferredInterests.enabled";
|
||
const PREF_NEWTAB_PING_ENABLED = "browser.newtabpage.ping.enabled";
|
||
const PREF_USER_INFERRED_PERSONALIZATION =
|
||
"discoverystream.sections.personalization.inferred.user.enabled";
|
||
const PREF_SYSTEM_INFERRED_PERSONALIZATION =
|
||
"discoverystream.sections.personalization.inferred.enabled";
|
||
|
||
// This is a mapping table between the user preferences and its encoding code
|
||
export const USER_PREFS_ENCODING = {
|
||
showSearch: 1 << 0,
|
||
"feeds.topsites": 1 << 1,
|
||
"feeds.section.topstories": 1 << 2,
|
||
"feeds.section.highlights": 1 << 3,
|
||
[PREF_SHOW_SPONSORED_STORIES]: 1 << 5,
|
||
"asrouter.userprefs.cfr.addons": 1 << 6,
|
||
"asrouter.userprefs.cfr.features": 1 << 7,
|
||
[PREF_SHOW_SPONSORED_TOPSITES]: 1 << 8,
|
||
};
|
||
|
||
const SURFACE_COUNTRY_MAP = {
|
||
// This will be expanded to other surfaces as we expand the reach of the private content ping
|
||
NEW_TAB_EN_US: ["US", "CA"],
|
||
NEW_TAB_DE_DE: ["DE", "CH", "AT"],
|
||
};
|
||
|
||
// Used as the missing value for timestamps in the session ping
|
||
const TIMESTAMP_MISSING_VALUE = -1;
|
||
|
||
// Page filter for onboarding telemetry, any value other than these will
|
||
// be set as "other"
|
||
const ONBOARDING_ALLOWED_PAGE_VALUES = [
|
||
"about:welcome",
|
||
"about:home",
|
||
"about:newtab",
|
||
];
|
||
|
||
const PREF_SURFACE_ID = "telemetry.surfaceId";
|
||
|
||
const ACTIVITY_STREAM_PREF_BRANCH = "browser.newtabpage.activity-stream.";
|
||
const NEWTAB_PING_PREFS = {
|
||
showSearch: Glean.newtabSearch.enabled,
|
||
"feeds.topsites": Glean.topsites.enabled,
|
||
[PREF_SHOW_SPONSORED_TOPSITES]: Glean.topsites.sponsoredEnabled,
|
||
"feeds.section.topstories": Glean.pocket.enabled,
|
||
[PREF_SHOW_SPONSORED_STORIES]: Glean.pocket.sponsoredStoriesEnabled,
|
||
topSitesRows: Glean.topsites.rows,
|
||
showWeather: Glean.newtab.weatherEnabled,
|
||
};
|
||
const TOP_SITES_BLOCKED_SPONSORS_PREF = "browser.topsites.blockedSponsors";
|
||
const TOPIC_SELECTION_SELECTED_TOPICS_PREF =
|
||
"browser.newtabpage.activity-stream.discoverystream.topicSelection.selectedTopics";
|
||
|
||
export class TelemetryFeed {
|
||
constructor() {
|
||
this.sessions = new Map();
|
||
this._prefs = new Prefs();
|
||
this._impressionId = this.getOrCreateImpressionId();
|
||
this._aboutHomeSeen = false;
|
||
this._classifySite = classifySite;
|
||
this._browserOpenNewtabStart = null;
|
||
this.newtabContentPing = new lazy.NewTabContentPing();
|
||
|
||
XPCOMUtils.defineLazyPreferenceGetter(
|
||
this,
|
||
"SHOW_SPONSORED_STORIES_ENABLED",
|
||
`${ACTIVITY_STREAM_PREF_BRANCH}${PREF_SHOW_SPONSORED_STORIES}`,
|
||
false
|
||
);
|
||
|
||
XPCOMUtils.defineLazyPreferenceGetter(
|
||
this,
|
||
"SHOW_SPONSORED_TOPSITES_ENABLED",
|
||
`${ACTIVITY_STREAM_PREF_BRANCH}${PREF_SHOW_SPONSORED_TOPSITES}`,
|
||
false
|
||
);
|
||
}
|
||
|
||
get telemetryEnabled() {
|
||
return this._prefs.get(TELEMETRY_PREF);
|
||
}
|
||
|
||
get eventTelemetryEnabled() {
|
||
return this._prefs.get(EVENTS_TELEMETRY_PREF);
|
||
}
|
||
|
||
get privatePingEnabled() {
|
||
return this._prefs.get(PREF_PRIVATE_PING_ENABLED);
|
||
}
|
||
|
||
get redactNewTabPingEnabled() {
|
||
return this._prefs.get(PREF_REDACT_NEWTAB_PING_NEABLED);
|
||
}
|
||
|
||
get privatePingInferredInterestsEnabled() {
|
||
return (
|
||
this._prefs.get(PREF_PRIVATE_PING_INFERRED_ENABLED) &&
|
||
this._prefs.get(PREF_USER_INFERRED_PERSONALIZATION) &&
|
||
this._prefs.get(PREF_SYSTEM_INFERRED_PERSONALIZATION)
|
||
);
|
||
}
|
||
|
||
get inferredInterests() {
|
||
return this.store.getState()?.InferredPersonalization
|
||
?.coarsePrivateInferredInterests;
|
||
}
|
||
|
||
get clientInfo() {
|
||
return lazy.ClientEnvironmentBase;
|
||
}
|
||
|
||
get canSendUnifiedAdsSpocCallbacks() {
|
||
const unifiedAdsSpocsEnabled = this._prefs.get(
|
||
PREF_UNIFIED_ADS_SPOCS_ENABLED
|
||
);
|
||
|
||
return unifiedAdsSpocsEnabled && this.SHOW_SPONSORED_STORIES_ENABLED;
|
||
}
|
||
|
||
get canSendUnifiedAdsTilesCallbacks() {
|
||
const unifiedAdsTilesEnabled = this._prefs.get(
|
||
PREF_UNIFIED_ADS_TILES_ENABLED
|
||
);
|
||
|
||
return unifiedAdsTilesEnabled && this.SHOW_SPONSORED_TOPSITES_ENABLED;
|
||
}
|
||
|
||
get telemetryClientId() {
|
||
Object.defineProperty(this, "telemetryClientId", {
|
||
value: lazy.ClientID.getClientID(),
|
||
});
|
||
return this.telemetryClientId;
|
||
}
|
||
|
||
get processStartTs() {
|
||
let startupInfo = Services.startup.getStartupInfo();
|
||
let processStartTs = startupInfo.process.getTime();
|
||
|
||
Object.defineProperty(this, "processStartTs", {
|
||
value: processStartTs,
|
||
});
|
||
return this.processStartTs;
|
||
}
|
||
|
||
init() {
|
||
this._beginObservingNewtabPingPrefs();
|
||
Services.obs.addObserver(
|
||
this.browserOpenNewtabStart,
|
||
"browser-open-newtab-start"
|
||
);
|
||
// Set two scalars for the "deletion-request" ping (See bug 1602064 and 1729474)
|
||
Glean.deletionRequest.impressionId.set(this._impressionId);
|
||
if (!lazy.ContextId.rotationEnabled) {
|
||
Glean.deletionRequest.contextId.set(
|
||
lazy.ContextId.requestSynchronously()
|
||
);
|
||
}
|
||
Glean.newtab.locale.set(Services.locale.appLocaleAsBCP47);
|
||
Glean.newtabHandoffPreference.enabled.set(
|
||
lazy.handoffToAwesomebarPrefValue
|
||
);
|
||
}
|
||
|
||
getOrCreateImpressionId() {
|
||
let impressionId = this._prefs.get(PREF_IMPRESSION_ID);
|
||
if (!impressionId) {
|
||
impressionId = String(Services.uuid.generateUUID());
|
||
this._prefs.set(PREF_IMPRESSION_ID, impressionId);
|
||
}
|
||
return impressionId;
|
||
}
|
||
|
||
browserOpenNewtabStart() {
|
||
let now = Cu.now();
|
||
this._browserOpenNewtabStart = Math.round(this.processStartTs + now);
|
||
|
||
ChromeUtils.addProfilerMarker(
|
||
"UserTiming",
|
||
now,
|
||
"browser-open-newtab-start"
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Retrieves most recently followed sections (maximum 2 sections)
|
||
* @returns {String[]} comma separated string of section UUID's
|
||
*/
|
||
getFollowedSections() {
|
||
const sections =
|
||
this.store?.getState()?.DiscoveryStream.sectionPersonalization;
|
||
if (sections) {
|
||
// filter to only include followedTopics
|
||
const followed = Object.entries(sections).filter(
|
||
([, info]) => info.isFollowed
|
||
);
|
||
// sort from most recently followed to oldest. If followedAt is falsey, treat it as the oldest
|
||
followed.sort((a, b) => {
|
||
const aDate = a[1].followedAt ? new Date(a[1].followedAt) : 0;
|
||
const bDate = b[1].followedAt ? new Date(b[1].followedAt) : 0;
|
||
return bDate - aDate;
|
||
});
|
||
|
||
return followed.slice(0, 2).map(([sectionId]) => sectionId);
|
||
}
|
||
return [];
|
||
}
|
||
|
||
setLoadTriggerInfo(port) {
|
||
// XXX note that there is a race condition here; we're assuming that no
|
||
// other tab will be interleaving calls to browserOpenNewtabStart and
|
||
// when at.NEW_TAB_INIT gets triggered by RemotePages and calls this
|
||
// method. For manually created windows, it's hard to imagine us hitting
|
||
// this race condition.
|
||
//
|
||
// However, for session restore, where multiple windows with multiple tabs
|
||
// might be restored much closer together in time, it's somewhat less hard,
|
||
// though it should still be pretty rare.
|
||
//
|
||
// The fix to this would be making all of the load-trigger notifications
|
||
// return some data with their notifications, and somehow propagate that
|
||
// data through closures into the tab itself so that we could match them
|
||
//
|
||
// As of this writing (very early days of system add-on perf telemetry),
|
||
// the hypothesis is that hitting this race should be so rare that makes
|
||
// more sense to live with the slight data inaccuracy that it would
|
||
// introduce, rather than doing the correct but complicated thing. It may
|
||
// well be worth reexamining this hypothesis after we have more experience
|
||
// with the data.
|
||
|
||
let data_to_save;
|
||
try {
|
||
if (!this._browserOpenNewtabStart) {
|
||
throw new Error("No browser-open-newtab-start recorded.");
|
||
}
|
||
data_to_save = {
|
||
load_trigger_ts: this._browserOpenNewtabStart,
|
||
load_trigger_type: "menu_plus_or_keyboard",
|
||
};
|
||
} catch (e) {
|
||
// if no mark was returned, we have nothing to save
|
||
return;
|
||
}
|
||
this.saveSessionPerfData(port, data_to_save);
|
||
}
|
||
|
||
/**
|
||
* Lazily initialize UTEventReporting to send pings
|
||
*/
|
||
get utEvents() {
|
||
Object.defineProperty(this, "utEvents", {
|
||
value: new lazy.UTEventReporting(),
|
||
});
|
||
return this.utEvents;
|
||
}
|
||
|
||
/**
|
||
* Get encoded user preferences, multiple prefs will be combined via bitwise OR operator
|
||
*/
|
||
get userPreferences() {
|
||
let prefs = 0;
|
||
|
||
for (const pref of Object.keys(USER_PREFS_ENCODING)) {
|
||
if (this._prefs.get(pref)) {
|
||
prefs |= USER_PREFS_ENCODING[pref];
|
||
}
|
||
}
|
||
return prefs;
|
||
}
|
||
|
||
/**
|
||
* Removes fields that link to any user content preference.
|
||
* Redactions only occur if the appropriate pref is enabled.
|
||
* @param {*} pingDict Input dictionary
|
||
* @param {boolean} isSponsored Is this in ad, in which case there is nothing we can redact currently
|
||
* @returns {*} Possibly redacted dictionary
|
||
*/
|
||
redactNewTabPing(pingDict, isSponsored = false) {
|
||
if (this.redactNewTabPingEnabled && !isSponsored) {
|
||
const {
|
||
// eslint-disable-next-line no-unused-vars
|
||
corpus_item_id,
|
||
// eslint-disable-next-line no-unused-vars
|
||
scheduled_corpus_item_id,
|
||
// eslint-disable-next-line no-unused-vars
|
||
section,
|
||
// eslint-disable-next-line no-unused-vars
|
||
selected_topics,
|
||
// eslint-disable-next-line no-unused-vars
|
||
tile_id,
|
||
// eslint-disable-next-line no-unused-vars
|
||
topic,
|
||
...result
|
||
} = pingDict;
|
||
return result;
|
||
}
|
||
return pingDict; // No modification
|
||
}
|
||
|
||
/**
|
||
* addSession - Start tracking a new session
|
||
*
|
||
* @param {string} id the portID of the open session
|
||
* @param {string} the URL being loaded for this session (optional)
|
||
* @return {obj} Session object
|
||
*/
|
||
addSession(id, url) {
|
||
// XXX refactor to use setLoadTriggerInfo or saveSessionPerfData
|
||
|
||
// "unexpected" will be overwritten when appropriate
|
||
let load_trigger_type = "unexpected";
|
||
let load_trigger_ts;
|
||
|
||
if (!this._aboutHomeSeen && url === "about:home") {
|
||
this._aboutHomeSeen = true;
|
||
|
||
// XXX note that this will be incorrectly set in the following cases:
|
||
// session_restore following by clicking on the toolbar button,
|
||
// or someone who has changed their default home page preference to
|
||
// something else and later clicks the toolbar. It will also be
|
||
// incorrectly unset if someone changes their "Home Page" preference to
|
||
// about:newtab.
|
||
//
|
||
// That said, the ratio of these mistakes to correct cases should
|
||
// be very small, and these issues should follow away as we implement
|
||
// the remaining load_trigger_type values for about:home in issue 3556.
|
||
//
|
||
// XXX file a bug to implement remaining about:home cases so this
|
||
// problem will go away and link to it here.
|
||
load_trigger_type = "first_window_opened";
|
||
|
||
// The real perceived trigger of first_window_opened is the OS-level
|
||
// clicking of the icon. We express this by using the process start
|
||
// absolute timestamp.
|
||
load_trigger_ts = this.processStartTs;
|
||
}
|
||
|
||
const session = {
|
||
session_id: String(Services.uuid.generateUUID()),
|
||
// "unknown" will be overwritten when appropriate
|
||
page: url ? url : "unknown",
|
||
perf: {
|
||
load_trigger_type,
|
||
is_preloaded: false,
|
||
},
|
||
};
|
||
|
||
if (load_trigger_ts) {
|
||
session.perf.load_trigger_ts = load_trigger_ts;
|
||
}
|
||
|
||
this.sessions.set(id, session);
|
||
return session;
|
||
}
|
||
|
||
/**
|
||
* endSession - Stop tracking a session
|
||
*
|
||
* @param {string} portID the portID of the session that just closed
|
||
*/
|
||
async endSession(portID) {
|
||
const session = this.sessions.get(portID);
|
||
|
||
if (!session) {
|
||
// It's possible the tab was never visible – in which case, there was no user session.
|
||
return;
|
||
}
|
||
|
||
Glean.newtab.closed.record({ newtab_visit_id: session.session_id });
|
||
if (
|
||
this.telemetryEnabled &&
|
||
Services.prefs.getBoolPref(PREF_NEWTAB_PING_ENABLED, true)
|
||
) {
|
||
GleanPings.newtab.submit("newtab_session_end");
|
||
if (this.privatePingEnabled) {
|
||
this.configureContentPing();
|
||
}
|
||
}
|
||
|
||
if (session.perf.visibility_event_rcvd_ts) {
|
||
let absNow = this.processStartTs + Cu.now();
|
||
session.session_duration = Math.round(
|
||
absNow - session.perf.visibility_event_rcvd_ts
|
||
);
|
||
|
||
// Rounding all timestamps in perf to ease the data processing on the backend.
|
||
// NB: use `TIMESTAMP_MISSING_VALUE` if the value is missing.
|
||
session.perf.visibility_event_rcvd_ts = Math.round(
|
||
session.perf.visibility_event_rcvd_ts
|
||
);
|
||
session.perf.load_trigger_ts = Math.round(
|
||
session.perf.load_trigger_ts || TIMESTAMP_MISSING_VALUE
|
||
);
|
||
session.perf.topsites_first_painted_ts = Math.round(
|
||
session.perf.topsites_first_painted_ts || TIMESTAMP_MISSING_VALUE
|
||
);
|
||
} else {
|
||
// This session was never shown (i.e. the hidden preloaded newtab), there was no user session either.
|
||
this.sessions.delete(portID);
|
||
return;
|
||
}
|
||
|
||
let sessionEndEvent = this.createSessionEndEvent(session);
|
||
this.sendUTEvent(sessionEndEvent, this.utEvents.sendSessionEndEvent);
|
||
this.sessions.delete(portID);
|
||
}
|
||
|
||
/**
|
||
* handleNewTabInit - Handle NEW_TAB_INIT, which creates a new session and sets the a flag
|
||
* for session.perf based on whether or not this new tab is preloaded
|
||
*
|
||
* @param {obj} action the Action object
|
||
*/
|
||
handleNewTabInit(action) {
|
||
const session = this.addSession(
|
||
au.getPortIdOfSender(action),
|
||
action.data.url
|
||
);
|
||
session.perf.is_preloaded =
|
||
action.data.browser.getAttribute("preloadedState") === "preloaded";
|
||
}
|
||
|
||
/**
|
||
* createPing - Create a ping with common properties
|
||
*
|
||
* @param {string} id The portID of the session, if a session is relevant (optional)
|
||
* @return {obj} A telemetry ping
|
||
*/
|
||
createPing(portID) {
|
||
const ping = {
|
||
addon_version: Services.appinfo.appBuildID,
|
||
locale: Services.locale.appLocaleAsBCP47,
|
||
user_prefs: this.userPreferences,
|
||
};
|
||
|
||
// If the ping is part of a user session, add session-related info
|
||
if (portID) {
|
||
const session = this.sessions.get(portID) || this.addSession(portID);
|
||
Object.assign(ping, { session_id: session.session_id });
|
||
|
||
if (session.page) {
|
||
Object.assign(ping, { page: session.page });
|
||
}
|
||
}
|
||
return ping;
|
||
}
|
||
|
||
createUserEvent(action) {
|
||
return Object.assign(
|
||
this.createPing(au.getPortIdOfSender(action)),
|
||
action.data,
|
||
{ action: "activity_stream_user_event" }
|
||
);
|
||
}
|
||
|
||
createSessionEndEvent(session) {
|
||
return Object.assign(this.createPing(), {
|
||
session_id: session.session_id,
|
||
page: session.page,
|
||
session_duration: session.session_duration,
|
||
action: "activity_stream_session",
|
||
perf: session.perf,
|
||
profile_creation_date:
|
||
lazy.TelemetryEnvironment.currentEnvironment.profile.resetDate ||
|
||
lazy.TelemetryEnvironment.currentEnvironment.profile.creationDate,
|
||
});
|
||
}
|
||
|
||
sendUTEvent(event_object, eventFunction) {
|
||
if (this.telemetryEnabled && this.eventTelemetryEnabled) {
|
||
eventFunction(event_object);
|
||
}
|
||
}
|
||
|
||
async handleTopSitesSponsoredImpressionStats(action) {
|
||
const { data } = action;
|
||
const {
|
||
type,
|
||
position,
|
||
source,
|
||
advertiser: advertiser_name,
|
||
tile_id,
|
||
} = data;
|
||
// Legacy telemetry expects 1-based tile positions.
|
||
const legacyTelemetryPosition = position + 1;
|
||
|
||
const unifiedAdsTilesEnabled = this._prefs.get(
|
||
PREF_UNIFIED_ADS_TILES_ENABLED
|
||
);
|
||
|
||
let pingType;
|
||
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
if (type === "impression") {
|
||
pingType = "topsites-impression";
|
||
Glean.contextualServicesTopsites.impression[
|
||
`${source}_${legacyTelemetryPosition}`
|
||
].add(1);
|
||
if (session) {
|
||
Glean.topsites.impression.record({
|
||
advertiser_name,
|
||
tile_id,
|
||
newtab_visit_id: session.session_id,
|
||
is_sponsored: true,
|
||
position,
|
||
});
|
||
}
|
||
} else if (type === "click") {
|
||
pingType = "topsites-click";
|
||
Glean.contextualServicesTopsites.click[
|
||
`${source}_${legacyTelemetryPosition}`
|
||
].add(1);
|
||
if (session) {
|
||
Glean.topsites.click.record({
|
||
advertiser_name,
|
||
tile_id,
|
||
newtab_visit_id: session.session_id,
|
||
is_sponsored: true,
|
||
position,
|
||
});
|
||
}
|
||
} else {
|
||
console.error("Unknown ping type for sponsored TopSites impression");
|
||
return;
|
||
}
|
||
|
||
Glean.topSites.pingType.set(pingType);
|
||
Glean.topSites.position.set(legacyTelemetryPosition);
|
||
Glean.topSites.source.set(source);
|
||
Glean.topSites.tileId.set(tile_id);
|
||
if (data.reporting_url && !unifiedAdsTilesEnabled) {
|
||
Glean.topSites.reportingUrl.set(data.reporting_url);
|
||
}
|
||
Glean.topSites.advertiser.set(advertiser_name);
|
||
Glean.topSites.contextId.set(await lazy.ContextId.request());
|
||
GleanPings.topSites.submit();
|
||
|
||
if (data.reporting_url && this.canSendUnifiedAdsTilesCallbacks) {
|
||
// Send callback events to MARS unified ads api
|
||
this.sendUnifiedAdsCallbackEvent({
|
||
url: data.reporting_url,
|
||
position,
|
||
});
|
||
}
|
||
}
|
||
|
||
handleTopSitesOrganicImpressionStats(action) {
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
if (!session) {
|
||
return;
|
||
}
|
||
|
||
switch (action.data?.type) {
|
||
case "impression":
|
||
Glean.topsites.impression.record({
|
||
newtab_visit_id: session.session_id,
|
||
is_sponsored: false,
|
||
position: action.data.position,
|
||
});
|
||
break;
|
||
|
||
case "click":
|
||
Glean.topsites.click.record({
|
||
newtab_visit_id: session.session_id,
|
||
is_sponsored: false,
|
||
position: action.data.position,
|
||
});
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
handleUserEvent(action) {
|
||
let userEvent = this.createUserEvent(action);
|
||
this.sendUTEvent(userEvent, this.utEvents.sendUserEvent);
|
||
}
|
||
|
||
handleDiscoveryStreamUserEvent(action) {
|
||
const pocket_logged_in_status = lazy.pktApi.isUserLoggedIn();
|
||
Glean.pocket.isSignedIn.set(pocket_logged_in_status);
|
||
this.handleUserEvent({
|
||
...action,
|
||
data: {
|
||
...(action.data || {}),
|
||
value: {
|
||
...(action.data?.value || {}),
|
||
pocket_logged_in_status,
|
||
},
|
||
},
|
||
});
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
|
||
switch (action.data?.event) {
|
||
// TODO: Determine if private window should be tracked?
|
||
// case "OPEN_PRIVATE_WINDOW":
|
||
case "OPEN_NEW_WINDOW":
|
||
case "CLICK": {
|
||
const {
|
||
card_type,
|
||
corpus_item_id,
|
||
event_source,
|
||
feature,
|
||
fetchTimestamp,
|
||
firstVisibleTimestamp,
|
||
format,
|
||
is_list_card,
|
||
is_section_followed,
|
||
matches_selected_topic,
|
||
received_rank,
|
||
recommendation_id,
|
||
recommended_at,
|
||
scheduled_corpus_item_id,
|
||
section_position,
|
||
section,
|
||
selected_topics,
|
||
shim,
|
||
tile_id,
|
||
topic,
|
||
} = action.data.value ?? {};
|
||
|
||
if (
|
||
action.data.source === "POPULAR_TOPICS" ||
|
||
card_type === "topics_widget"
|
||
) {
|
||
Glean.pocket.topicClick.record({
|
||
newtab_visit_id: session.session_id,
|
||
topic,
|
||
});
|
||
} else if (action.data.source === "FEATURE_HIGHLIGHT") {
|
||
Glean.newtab.tooltipClick.record({
|
||
newtab_visit_id: session.session_id,
|
||
feature,
|
||
});
|
||
} else if (["spoc", "organic"].includes(card_type)) {
|
||
const is_sponsored = card_type === "spoc";
|
||
const gleanData = {
|
||
newtab_visit_id: session.session_id,
|
||
is_sponsored,
|
||
...(format ? { format } : {}),
|
||
...(section
|
||
? {
|
||
section,
|
||
section_position,
|
||
is_section_followed,
|
||
}
|
||
: {}),
|
||
matches_selected_topic,
|
||
selected_topics,
|
||
topic,
|
||
is_list_card,
|
||
position: action.data.action_position,
|
||
tile_id,
|
||
event_source,
|
||
// We conditionally add in a few props.
|
||
...(corpus_item_id ? { corpus_item_id } : {}),
|
||
...(scheduled_corpus_item_id ? { scheduled_corpus_item_id } : {}),
|
||
...(corpus_item_id || scheduled_corpus_item_id
|
||
? {
|
||
received_rank,
|
||
recommended_at,
|
||
}
|
||
: {
|
||
recommendation_id,
|
||
}),
|
||
};
|
||
|
||
Glean.pocket.click.record({
|
||
...this.redactNewTabPing(gleanData, is_sponsored),
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
|
||
if (this.privatePingEnabled && !is_sponsored) {
|
||
this.newtabContentPing.recordEvent("click", gleanData);
|
||
}
|
||
if (shim) {
|
||
if (this.canSendUnifiedAdsSpocCallbacks) {
|
||
// Send unified ads callback event
|
||
this.sendUnifiedAdsCallbackEvent({
|
||
url: shim,
|
||
position: action.data.action_position,
|
||
});
|
||
} else {
|
||
Glean.pocket.shim.set(shim);
|
||
if (fetchTimestamp) {
|
||
Glean.pocket.fetchTimestamp.set(fetchTimestamp * 1000);
|
||
}
|
||
if (firstVisibleTimestamp) {
|
||
Glean.pocket.newtabCreationTimestamp.set(
|
||
firstVisibleTimestamp * 1000
|
||
);
|
||
}
|
||
GleanPings.spoc.submit("click");
|
||
}
|
||
}
|
||
}
|
||
|
||
break;
|
||
}
|
||
case "POCKET_THUMBS_DOWN":
|
||
case "POCKET_THUMBS_UP": {
|
||
const {
|
||
corpus_item_id,
|
||
format,
|
||
is_section_followed,
|
||
received_rank,
|
||
recommendation_id,
|
||
recommended_at,
|
||
scheduled_corpus_item_id,
|
||
section_position,
|
||
section,
|
||
thumbs_down,
|
||
thumbs_up,
|
||
tile_id,
|
||
topic,
|
||
} = action.data.value ?? {};
|
||
const gleanData = {
|
||
tile_id,
|
||
// We conditionally add in a few props.
|
||
...(corpus_item_id ? { corpus_item_id } : {}),
|
||
...(scheduled_corpus_item_id ? { scheduled_corpus_item_id } : {}),
|
||
...(corpus_item_id || scheduled_corpus_item_id
|
||
? {
|
||
received_rank,
|
||
recommended_at,
|
||
}
|
||
: {
|
||
recommendation_id,
|
||
}),
|
||
thumbs_up,
|
||
thumbs_down,
|
||
topic,
|
||
...(format ? { format } : {}),
|
||
...(section
|
||
? {
|
||
section,
|
||
section_position,
|
||
is_section_followed,
|
||
}
|
||
: {}),
|
||
};
|
||
Glean.pocket.thumbVotingInteraction.record({
|
||
...this.redactNewTabPing(gleanData),
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
if (this.privatePingEnabled) {
|
||
this.newtabContentPing.recordEvent(
|
||
"thumbVotingInteraction",
|
||
gleanData
|
||
);
|
||
}
|
||
break;
|
||
}
|
||
case "SAVE_TO_POCKET": {
|
||
const {
|
||
card_type,
|
||
corpus_item_id,
|
||
fetchTimestamp,
|
||
format,
|
||
is_list_card,
|
||
is_section_followed,
|
||
matches_selected_topic,
|
||
newtabCreationTimestamp,
|
||
received_rank,
|
||
recommendation_id,
|
||
recommended_at,
|
||
scheduled_corpus_item_id,
|
||
section_position,
|
||
section,
|
||
selected_topics,
|
||
shim,
|
||
tile_id,
|
||
topic,
|
||
} = action.data.value ?? {};
|
||
Glean.pocket.save.record({
|
||
newtab_visit_id: session.session_id,
|
||
is_sponsored: card_type === "spoc",
|
||
...(format ? { format } : {}),
|
||
...(section
|
||
? {
|
||
section,
|
||
section_position,
|
||
is_section_followed,
|
||
}
|
||
: {}),
|
||
topic,
|
||
matches_selected_topic,
|
||
selected_topics,
|
||
position: action.data.action_position,
|
||
tile_id,
|
||
is_list_card,
|
||
// We conditionally add in a few props.
|
||
...(corpus_item_id ? { corpus_item_id } : {}),
|
||
...(scheduled_corpus_item_id ? { scheduled_corpus_item_id } : {}),
|
||
...(corpus_item_id || scheduled_corpus_item_id
|
||
? {
|
||
received_rank,
|
||
recommended_at,
|
||
}
|
||
: {
|
||
recommendation_id,
|
||
}),
|
||
});
|
||
if (shim) {
|
||
Glean.pocket.shim.set(shim);
|
||
if (fetchTimestamp) {
|
||
Glean.pocket.fetchTimestamp.set(fetchTimestamp * 1000);
|
||
}
|
||
if (newtabCreationTimestamp) {
|
||
Glean.pocket.newtabCreationTimestamp.set(
|
||
newtabCreationTimestamp * 1000
|
||
);
|
||
}
|
||
GleanPings.spoc.submit("save");
|
||
}
|
||
break;
|
||
}
|
||
case "FAKESPOT_CLICK": {
|
||
const { product_id, category } = action.data.value ?? {};
|
||
Glean.newtab.fakespotClick.record({
|
||
newtab_visit_id: session.session_id,
|
||
product_id,
|
||
category,
|
||
});
|
||
break;
|
||
}
|
||
case "FAKESPOT_CATEGORY": {
|
||
const { category } = action.data.value ?? {};
|
||
Glean.newtab.fakespotCategory.record({
|
||
newtab_visit_id: session.session_id,
|
||
category,
|
||
});
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* This function submits callback events to the MARS unified ads service.
|
||
*/
|
||
|
||
async sendUnifiedAdsCallbackEvent(data = { url: null, position: null }) {
|
||
if (!data.url) {
|
||
throw new Error(
|
||
`[Unified ads callback] Missing argument (No url). Cannot send telemetry event.`
|
||
);
|
||
}
|
||
|
||
// data.position can be 0 (0)
|
||
if (!data.position && data.position !== 0) {
|
||
throw new Error(
|
||
`[Unified ads callback] Missing argument (No position). Cannot send telemetry event.`
|
||
);
|
||
}
|
||
|
||
// Make sure the callback endpoint is allowed
|
||
const allowed =
|
||
this._prefs
|
||
.get(PREF_ENDPOINTS)
|
||
.split(",")
|
||
.map(item => item.trim())
|
||
.filter(item => item) || [];
|
||
if (!allowed.some(prefix => data.url.startsWith(prefix))) {
|
||
throw new Error(
|
||
`[Unified ads callback] Not one of allowed prefixes (${allowed})`
|
||
);
|
||
}
|
||
|
||
const url = new URL(data.url);
|
||
url.searchParams.append("position", data.position);
|
||
|
||
try {
|
||
await fetch(url.toString());
|
||
} catch (error) {
|
||
console.error("Error:", error);
|
||
}
|
||
}
|
||
|
||
async sendPageTakeoverData() {
|
||
if (this.telemetryEnabled) {
|
||
const value = {};
|
||
let homeAffected = false;
|
||
let newtabCategory = "disabled";
|
||
let homePageCategory = "disabled";
|
||
|
||
// Check whether or not about:home and about:newtab are set to a custom URL.
|
||
// If so, classify them.
|
||
if (Services.prefs.getBoolPref("browser.newtabpage.enabled")) {
|
||
newtabCategory = "enabled";
|
||
if (
|
||
lazy.AboutNewTab.newTabURLOverridden &&
|
||
!lazy.AboutNewTab.newTabURL.startsWith("moz-extension://")
|
||
) {
|
||
value.newtab_url_category = await this._classifySite(
|
||
lazy.AboutNewTab.newTabURL
|
||
);
|
||
newtabCategory = value.newtab_url_category;
|
||
}
|
||
}
|
||
// Check if the newtab page setting is controlled by an extension.
|
||
await lazy.ExtensionSettingsStore.initialize();
|
||
const newtabExtensionInfo = lazy.ExtensionSettingsStore.getSetting(
|
||
"url_overrides",
|
||
"newTabURL"
|
||
);
|
||
if (newtabExtensionInfo && newtabExtensionInfo.id) {
|
||
value.newtab_extension_id = newtabExtensionInfo.id;
|
||
newtabCategory = "extension";
|
||
}
|
||
|
||
const homePageURL = lazy.HomePage.get();
|
||
if (
|
||
!["about:home", "about:blank", BLANK_HOMEPAGE_URL].includes(
|
||
homePageURL
|
||
) &&
|
||
!homePageURL.startsWith("moz-extension://")
|
||
) {
|
||
value.home_url_category = await this._classifySite(homePageURL);
|
||
homeAffected = true;
|
||
homePageCategory = value.home_url_category;
|
||
}
|
||
const homeExtensionInfo = lazy.ExtensionSettingsStore.getSetting(
|
||
"prefs",
|
||
"homepage_override"
|
||
);
|
||
if (homeExtensionInfo && homeExtensionInfo.id) {
|
||
value.home_extension_id = homeExtensionInfo.id;
|
||
homeAffected = true;
|
||
homePageCategory = "extension";
|
||
}
|
||
if (!homeAffected && !lazy.HomePage.overridden) {
|
||
homePageCategory = "enabled";
|
||
}
|
||
|
||
Glean.newtab.newtabCategory.set(newtabCategory);
|
||
Glean.newtab.homepageCategory.set(homePageCategory);
|
||
|
||
if (Services.prefs.getBoolPref(PREF_NEWTAB_PING_ENABLED, true)) {
|
||
if (this.privatePingEnabled) {
|
||
this.configureContentPing();
|
||
}
|
||
GleanPings.newtab.submit("component_init");
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Populates the newtab-content ping with metrics, and the schedules
|
||
* submission of the ping via NewTabContentPing.
|
||
*/
|
||
async configureContentPing() {
|
||
let privateMetrics = {};
|
||
|
||
const inferredInterests =
|
||
this.privatePingInferredInterestsEnabled && this.inferredInterests;
|
||
if (inferredInterests) {
|
||
privateMetrics.inferredInterests = inferredInterests;
|
||
}
|
||
|
||
// When we have a coarse interest vector we want to make sure there isn't
|
||
// anything additionaly identifable as a unique identifier. Therefore,
|
||
// when interest vectors are used we reduce our context profile somewhat.
|
||
const reduceTrackingInformation = !!inferredInterests;
|
||
|
||
if (!reduceTrackingInformation) {
|
||
privateMetrics.coarseOs = lazy.NewTabUtils.normalizeOs();
|
||
const followed = this.getFollowedSections();
|
||
privateMetrics.followedSections = followed;
|
||
}
|
||
const surfaceId = this._prefs.get(PREF_SURFACE_ID);
|
||
privateMetrics.surfaceId = surfaceId;
|
||
|
||
const curCountry = lazy.Region.home;
|
||
if (
|
||
SURFACE_COUNTRY_MAP[surfaceId] &&
|
||
SURFACE_COUNTRY_MAP[surfaceId].includes(curCountry)
|
||
) {
|
||
// Only include supported current countries for the surface to reduce identifiability
|
||
privateMetrics.country = curCountry;
|
||
}
|
||
privateMetrics.utcOffset = lazy.NewTabUtils.getUtcOffset(surfaceId);
|
||
|
||
// To prevent fingerprinting we only send current experiment / branch
|
||
const experimentMetadata =
|
||
lazy.NimbusFeatures.pocketNewtab.getEnrollmentMetadata();
|
||
privateMetrics.experimentName = experimentMetadata?.slug ?? "";
|
||
|
||
privateMetrics.experimentBranch = experimentMetadata?.branch ?? "";
|
||
|
||
this.newtabContentPing.scheduleSubmission(privateMetrics);
|
||
}
|
||
|
||
async onAction(action) {
|
||
switch (action.type) {
|
||
case at.INIT:
|
||
this.init();
|
||
await this.sendPageTakeoverData();
|
||
break;
|
||
case at.NEW_TAB_INIT:
|
||
this.handleNewTabInit(action);
|
||
break;
|
||
case at.NEW_TAB_UNLOAD:
|
||
this.endSession(au.getPortIdOfSender(action));
|
||
break;
|
||
case at.SAVE_SESSION_PERF_DATA:
|
||
this.saveSessionPerfData(au.getPortIdOfSender(action), action.data);
|
||
break;
|
||
case at.DISCOVERY_STREAM_IMPRESSION_STATS:
|
||
this.handleDiscoveryStreamImpressionStats(
|
||
au.getPortIdOfSender(action),
|
||
action.data
|
||
);
|
||
break;
|
||
case at.DISCOVERY_STREAM_USER_EVENT:
|
||
this.handleDiscoveryStreamUserEvent(action);
|
||
break;
|
||
case at.TELEMETRY_USER_EVENT:
|
||
this.handleUserEvent(action);
|
||
break;
|
||
case at.TOP_SITES_SPONSORED_IMPRESSION_STATS:
|
||
this.handleTopSitesSponsoredImpressionStats(action);
|
||
break;
|
||
case at.TOP_SITES_ORGANIC_IMPRESSION_STATS:
|
||
this.handleTopSitesOrganicImpressionStats(action);
|
||
break;
|
||
case at.UNINIT:
|
||
this.uninit();
|
||
break;
|
||
case at.ABOUT_SPONSORED_TOP_SITES:
|
||
this.handleAboutSponsoredTopSites(action);
|
||
break;
|
||
case at.BLOCK_URL:
|
||
this.handleBlockUrl(action);
|
||
break;
|
||
case at.WALLPAPER_CATEGORY_CLICK:
|
||
case at.WALLPAPER_CLICK:
|
||
case at.WALLPAPERS_FEATURE_HIGHLIGHT_DISMISSED:
|
||
case at.WALLPAPERS_FEATURE_HIGHLIGHT_CTA_CLICKED:
|
||
case at.WALLPAPER_UPLOAD:
|
||
this.handleWallpaperUserEvent(action);
|
||
break;
|
||
case at.SET_PREF:
|
||
this.handleSetPref(action);
|
||
break;
|
||
case at.WEATHER_IMPRESSION:
|
||
case at.WEATHER_LOAD_ERROR:
|
||
case at.WEATHER_OPEN_PROVIDER_URL:
|
||
case at.WEATHER_LOCATION_DATA_UPDATE:
|
||
this.handleWeatherUserEvent(action);
|
||
break;
|
||
case at.TOPIC_SELECTION_USER_OPEN:
|
||
case at.TOPIC_SELECTION_USER_DISMISS:
|
||
case at.TOPIC_SELECTION_USER_SAVE:
|
||
this.handleTopicSelectionUserEvent(action);
|
||
break;
|
||
case at.FAKESPOT_DISMISS: {
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
if (session) {
|
||
Glean.newtab.fakespotDismiss.record({
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
}
|
||
break;
|
||
}
|
||
case at.FAKESPOT_CTA_CLICK: {
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
if (session) {
|
||
Glean.newtab.fakespotCtaClick.record({
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
}
|
||
break;
|
||
}
|
||
case at.OPEN_ABOUT_FAKESPOT: {
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
if (session) {
|
||
Glean.newtab.fakespotAboutClick.record({
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
}
|
||
break;
|
||
}
|
||
case at.BLOCK_SECTION:
|
||
// Intentional fall-through
|
||
case at.CARD_SECTION_IMPRESSION:
|
||
// Intentional fall-through
|
||
case at.FOLLOW_SECTION:
|
||
// Intentional fall-through
|
||
case at.UNBLOCK_SECTION:
|
||
// Intentional fall-through
|
||
case at.UNFOLLOW_SECTION: {
|
||
this.handleCardSectionUserEvent(action);
|
||
break;
|
||
}
|
||
case at.INLINE_SELECTION_CLICK:
|
||
// Intentional fall-through
|
||
case at.INLINE_SELECTION_IMPRESSION:
|
||
this.handleInlineSelectionUserEvent(action);
|
||
break;
|
||
case at.REPORT_AD_OPEN:
|
||
case at.REPORT_AD_SUBMIT:
|
||
this.handleReportAdUserEvent(action);
|
||
break;
|
||
case at.REPORT_CONTENT_OPEN:
|
||
case at.REPORT_CONTENT_SUBMIT:
|
||
this.handleReportContentUserEvent(action);
|
||
break;
|
||
}
|
||
}
|
||
|
||
async handleReportAdUserEvent(action) {
|
||
const { placement_id, position, report_reason, reporting_url } =
|
||
action.data || {};
|
||
|
||
const url = new URL(reporting_url);
|
||
url.searchParams.append("placement_id", placement_id);
|
||
url.searchParams.append("reason", report_reason);
|
||
url.searchParams.append("position", position);
|
||
const adResponse = url.toString();
|
||
|
||
const allowed =
|
||
this._prefs
|
||
.get(PREF_ENDPOINTS)
|
||
.split(",")
|
||
.map(item => item.trim())
|
||
.filter(item => item) || [];
|
||
|
||
if (!allowed.some(prefix => adResponse.startsWith(prefix))) {
|
||
throw new Error(
|
||
`[Unified ads callback] Not one of allowed prefixes (${allowed})`
|
||
);
|
||
}
|
||
|
||
try {
|
||
await fetch(adResponse);
|
||
} catch (error) {
|
||
console.error("Error:", error);
|
||
}
|
||
}
|
||
|
||
handleReportContentUserEvent(action) {
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
const {
|
||
card_type,
|
||
corpus_item_id,
|
||
is_section_followed,
|
||
received_rank,
|
||
recommended_at,
|
||
report_reason,
|
||
scheduled_corpus_item_id,
|
||
section_position,
|
||
section,
|
||
title,
|
||
topic,
|
||
url,
|
||
} = action.data || {};
|
||
|
||
if (session) {
|
||
switch (action.type) {
|
||
case "REPORT_CONTENT_OPEN":
|
||
Glean.newtab.reportContentOpen.record({
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
break;
|
||
case "REPORT_CONTENT_SUBMIT":
|
||
Glean.newtab.reportContentSubmit.record({
|
||
card_type,
|
||
corpus_item_id,
|
||
is_section_followed,
|
||
newtab_visit_id: session.session_id,
|
||
received_rank,
|
||
recommended_at,
|
||
report_reason,
|
||
scheduled_corpus_item_id,
|
||
section_position,
|
||
section,
|
||
title,
|
||
topic,
|
||
url,
|
||
});
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
handleCardSectionUserEvent(action) {
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
if (session) {
|
||
const { section, section_position, event_source, is_section_followed } =
|
||
action.data;
|
||
const gleanDataForPrivatePing = {
|
||
section,
|
||
section_position,
|
||
event_source,
|
||
};
|
||
|
||
const gleanDataForNewtabPing = {
|
||
...gleanDataForPrivatePing,
|
||
newtab_visit_id: session.session_id,
|
||
};
|
||
|
||
switch (action.type) {
|
||
case "BLOCK_SECTION":
|
||
Glean.newtab.sectionsBlockSection.record(
|
||
this.redactNewTabPing(gleanDataForNewtabPing)
|
||
);
|
||
if (this.privatePingEnabled) {
|
||
this.newtabContentPing.recordEvent(
|
||
"sectionsBlockSection",
|
||
gleanDataForPrivatePing
|
||
);
|
||
}
|
||
break;
|
||
case "UNBLOCK_SECTION":
|
||
Glean.newtab.sectionsUnblockSection.record(
|
||
this.redactNewTabPing(gleanDataForNewtabPing)
|
||
);
|
||
if (this.privatePingEnabled) {
|
||
this.newtabContentPing.recordEvent(
|
||
"sectionsUnblockSection",
|
||
gleanDataForPrivatePing
|
||
);
|
||
}
|
||
break;
|
||
case "CARD_SECTION_IMPRESSION":
|
||
Glean.newtab.sectionsImpression.record(
|
||
this.redactNewTabPing({
|
||
newtab_visit_id: session.session_id,
|
||
section,
|
||
section_position,
|
||
is_section_followed,
|
||
})
|
||
);
|
||
if (this.privatePingEnabled) {
|
||
this.newtabContentPing.recordEvent("sectionsImpression", {
|
||
section,
|
||
section_position,
|
||
is_section_followed,
|
||
});
|
||
}
|
||
break;
|
||
case "FOLLOW_SECTION": {
|
||
Glean.newtab.sectionsFollowSection.record(
|
||
this.redactNewTabPing(gleanDataForNewtabPing)
|
||
);
|
||
if (this.privatePingEnabled) {
|
||
this.newtabContentPing.recordEvent(
|
||
"sectionsFollowSection",
|
||
gleanDataForPrivatePing
|
||
);
|
||
}
|
||
break;
|
||
}
|
||
case "UNFOLLOW_SECTION":
|
||
Glean.newtab.sectionsUnfollowSection.record(
|
||
this.redactNewTabPing(gleanDataForNewtabPing)
|
||
);
|
||
if (this.privatePingEnabled) {
|
||
this.newtabContentPing.recordEvent(
|
||
"sectionsUnfollowSection",
|
||
gleanDataForPrivatePing
|
||
);
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
handleInlineSelectionUserEvent(action) {
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
if (session) {
|
||
switch (action.type) {
|
||
case "INLINE_SELECTION_CLICK": {
|
||
const { topic, section_position, position, is_followed } =
|
||
action.data;
|
||
Glean.newtab.inlineSelectionClick.record({
|
||
newtab_visit_id: session.session_id,
|
||
topic,
|
||
section_position,
|
||
position,
|
||
is_followed,
|
||
});
|
||
break;
|
||
}
|
||
case "INLINE_SELECTION_IMPRESSION":
|
||
Glean.newtab.inlineSelectionImpression.record({
|
||
newtab_visit_id: session.session_id,
|
||
section_position: action.data.section_position,
|
||
});
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
handleTopicSelectionUserEvent(action) {
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
if (session) {
|
||
switch (action.type) {
|
||
case "TOPIC_SELECTION_USER_OPEN":
|
||
Glean.newtab.topicSelectionOpen.record({
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
break;
|
||
case "TOPIC_SELECTION_USER_DISMISS":
|
||
Glean.newtab.topicSelectionDismiss.record({
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
break;
|
||
case "TOPIC_SELECTION_USER_SAVE":
|
||
Glean.newtab.topicSelectionTopicsSaved.record({
|
||
newtab_visit_id: session.session_id,
|
||
topics: action.data.topics,
|
||
previous_topics: action.data.previous_topics,
|
||
first_save: action.data.first_save,
|
||
});
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
handleSetPref(action) {
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
if (action.data.name === "weather.display") {
|
||
if (!session) {
|
||
return;
|
||
}
|
||
Glean.newtab.weatherChangeDisplay.record({
|
||
newtab_visit_id: session.session_id,
|
||
weather_display_mode: action.data.value,
|
||
});
|
||
}
|
||
}
|
||
|
||
handleWeatherUserEvent(action) {
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
|
||
if (!session) {
|
||
return;
|
||
}
|
||
|
||
// Weather specific telemtry events can be added and parsed here.
|
||
switch (action.type) {
|
||
case "WEATHER_IMPRESSION":
|
||
Glean.newtab.weatherImpression.record({
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
break;
|
||
case "WEATHER_LOAD_ERROR":
|
||
Glean.newtab.weatherLoadError.record({
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
break;
|
||
case "WEATHER_OPEN_PROVIDER_URL":
|
||
Glean.newtab.weatherOpenProviderUrl.record({
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
break;
|
||
case "WEATHER_LOCATION_DATA_UPDATE":
|
||
Glean.newtab.weatherLocationSelected.record({
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
handleWallpaperUserEvent(action) {
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
|
||
if (!session) {
|
||
return;
|
||
}
|
||
|
||
const { data } = action;
|
||
|
||
// Wallpaper specific telemtry events can be added and parsed here.
|
||
switch (action.type) {
|
||
case "WALLPAPER_CATEGORY_CLICK":
|
||
Glean.newtab.wallpaperCategoryClick.record({
|
||
newtab_visit_id: session.session_id,
|
||
selected_category: action.data,
|
||
});
|
||
break;
|
||
case "WALLPAPER_CLICK":
|
||
{
|
||
const {
|
||
selected_wallpaper,
|
||
had_previous_wallpaper,
|
||
had_uploaded_previously,
|
||
} = data;
|
||
|
||
// if either of the wallpaper prefs are truthy, they had a previous wallpaper
|
||
Glean.newtab.wallpaperClick.record({
|
||
newtab_visit_id: session.session_id,
|
||
selected_wallpaper,
|
||
had_previous_wallpaper,
|
||
had_uploaded_previously,
|
||
});
|
||
}
|
||
break;
|
||
case "WALLPAPERS_FEATURE_HIGHLIGHT_CTA_CLICKED":
|
||
Glean.newtab.wallpaperHighlightCtaClick.record({
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
break;
|
||
case "WALLPAPERS_FEATURE_HIGHLIGHT_DISMISSED":
|
||
Glean.newtab.wallpaperHighlightDismissed.record({
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
handleBlockUrl(action) {
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
// TODO: Do we want to not send this unless there's a newtab_visit_id?
|
||
if (!session) {
|
||
return;
|
||
}
|
||
|
||
// Despite the action name, this is actually a bulk dismiss action:
|
||
// it can be applied to multiple topsites simultaneously.
|
||
const { data } = action;
|
||
for (const datum of data) {
|
||
const { corpus_item_id, scheduled_corpus_item_id } = datum;
|
||
if (datum.is_pocket_card) {
|
||
const gleanData = {
|
||
is_sponsored: datum.card_type === "spoc",
|
||
...(datum.format ? { format: datum.format } : {}),
|
||
position: datum.pos,
|
||
tile_id: datum.id || datum.tile_id,
|
||
is_list_card: datum.is_list_card,
|
||
...(datum.section
|
||
? {
|
||
section: datum.section,
|
||
section_position: datum.section_position,
|
||
is_section_followed: datum.is_section_followed,
|
||
}
|
||
: {}),
|
||
// We conditionally add in a few props.
|
||
...(corpus_item_id ? { corpus_item_id } : {}),
|
||
...(scheduled_corpus_item_id ? { scheduled_corpus_item_id } : {}),
|
||
...(corpus_item_id || scheduled_corpus_item_id
|
||
? {
|
||
received_rank: datum.received_rank,
|
||
recommended_at: datum.recommended_at,
|
||
}
|
||
: {
|
||
recommendation_id: datum.recommendation_id,
|
||
}),
|
||
};
|
||
Glean.pocket.dismiss.record({
|
||
...gleanData,
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
if (this.privatePingEnabled) {
|
||
this.newtabContentPing.recordEvent("dismiss", gleanData);
|
||
}
|
||
continue;
|
||
}
|
||
// Only log a topsites.dismiss telemetry event if the action came from TopSites section
|
||
if (action.source === "TOP_SITES") {
|
||
const { position, advertiser_name, tile_id, isSponsoredTopSite } =
|
||
datum;
|
||
Glean.topsites.dismiss.record({
|
||
advertiser_name,
|
||
tile_id,
|
||
newtab_visit_id: session.session_id,
|
||
is_sponsored: !!isSponsoredTopSite,
|
||
position,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
handleAboutSponsoredTopSites(action) {
|
||
const session = this.sessions.get(au.getPortIdOfSender(action));
|
||
const { data } = action;
|
||
const { position, advertiser_name, tile_id } = data;
|
||
|
||
if (session) {
|
||
Glean.topsites.showPrivacyClick.record({
|
||
advertiser_name,
|
||
tile_id,
|
||
newtab_visit_id: session.session_id,
|
||
position,
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Handle impression stats actions from Discovery Stream.
|
||
*
|
||
* @param {String} port The session port with which this is associated
|
||
* @param {Object} data The impression data structured as {source: "SOURCE", tiles: [{id: 123}]}
|
||
*
|
||
*/
|
||
handleDiscoveryStreamImpressionStats(port, data) {
|
||
let session = this.sessions.get(port);
|
||
|
||
if (!session) {
|
||
throw new Error("Session does not exist.");
|
||
}
|
||
|
||
const { tiles } = data;
|
||
|
||
tiles.forEach(tile => {
|
||
// if the tile has a category it is a product tile from fakespot
|
||
if (tile.type === "fakespot") {
|
||
Glean.newtab.fakespotProductImpression.record({
|
||
newtab_visit_id: session.session_id,
|
||
product_id: tile.id,
|
||
category: tile.category,
|
||
});
|
||
} else {
|
||
const { corpus_item_id, scheduled_corpus_item_id } = tile;
|
||
const is_sponsored = tile.type === "spoc";
|
||
const gleanData = {
|
||
is_sponsored,
|
||
...(tile.format ? { format: tile.format } : {}),
|
||
...(tile.section
|
||
? {
|
||
section: tile.section,
|
||
section_position: tile.section_position,
|
||
is_section_followed: tile.is_section_followed,
|
||
}
|
||
: {}),
|
||
position: tile.pos,
|
||
tile_id: tile.id,
|
||
topic: tile.topic,
|
||
selected_topics: tile.selectedTopics,
|
||
is_list_card: tile.is_list_card,
|
||
// We conditionally add in a few props.
|
||
...(corpus_item_id ? { corpus_item_id } : {}),
|
||
...(scheduled_corpus_item_id ? { scheduled_corpus_item_id } : {}),
|
||
...(corpus_item_id || scheduled_corpus_item_id
|
||
? {
|
||
received_rank: tile.received_rank,
|
||
recommended_at: tile.recommended_at,
|
||
}
|
||
: {
|
||
recommendation_id: tile.recommendation_id,
|
||
}),
|
||
};
|
||
Glean.pocket.impression.record({
|
||
...this.redactNewTabPing(gleanData, is_sponsored),
|
||
newtab_visit_id: session.session_id,
|
||
});
|
||
|
||
if (this.privatePingEnabled) {
|
||
this.newtabContentPing.recordEvent("impression", gleanData);
|
||
}
|
||
}
|
||
if (tile.shim) {
|
||
if (this.canSendUnifiedAdsSpocCallbacks) {
|
||
// Send unified ads callback event
|
||
this.sendUnifiedAdsCallbackEvent({
|
||
url: tile.shim,
|
||
position: tile.pos,
|
||
});
|
||
} else {
|
||
Glean.pocket.shim.set(tile.shim);
|
||
if (tile.fetchTimestamp) {
|
||
Glean.pocket.fetchTimestamp.set(tile.fetchTimestamp * 1000);
|
||
}
|
||
if (data.firstVisibleTimestamp) {
|
||
Glean.pocket.newtabCreationTimestamp.set(
|
||
data.firstVisibleTimestamp * 1000
|
||
);
|
||
}
|
||
GleanPings.spoc.submit("impression");
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Take all enumerable members of the data object and merge them into
|
||
* the session.perf object for the given port, so that it is sent to the
|
||
* server when the session ends. All members of the data object should
|
||
* be valid values of the perf object, as defined in pings.js and the
|
||
* data*.md documentation.
|
||
*
|
||
* @note Any existing keys with the same names already in the
|
||
* session perf object will be overwritten by values passed in here.
|
||
*
|
||
* @param {String} port The session with which this is associated
|
||
* @param {Object} data The perf data to be
|
||
*/
|
||
saveSessionPerfData(port, data) {
|
||
// XXX should use try/catch and send a bad state indicator if this
|
||
// get blows up.
|
||
let session = this.sessions.get(port);
|
||
|
||
// XXX Partial workaround for #3118; avoids the worst incorrect associations
|
||
// of times with browsers, by associating the load trigger with the
|
||
// visibility event as the user is most likely associating the trigger to
|
||
// the tab just shown. This helps avoid associating with a preloaded
|
||
// browser as those don't get the event until shown. Better fix for more
|
||
// cases forthcoming.
|
||
//
|
||
// XXX the about:home check (and the corresponding test) should go away
|
||
// once the load_trigger stuff in addSession is refactored into
|
||
// setLoadTriggerInfo.
|
||
//
|
||
if (data.visibility_event_rcvd_ts && session.page !== "about:home") {
|
||
this.setLoadTriggerInfo(port);
|
||
}
|
||
|
||
let timestamp = data.topsites_first_painted_ts;
|
||
|
||
if (
|
||
timestamp &&
|
||
session.page === "about:home" &&
|
||
!lazy.HomePage.overridden &&
|
||
Services.prefs.getIntPref("browser.startup.page") === 1
|
||
) {
|
||
lazy.AboutNewTab.maybeRecordTopsitesPainted(timestamp);
|
||
}
|
||
|
||
Object.assign(session.perf, data);
|
||
|
||
if (data.visibility_event_rcvd_ts && !session.newtabOpened) {
|
||
session.newtabOpened = true;
|
||
const source = ONBOARDING_ALLOWED_PAGE_VALUES.includes(session.page)
|
||
? session.page
|
||
: "other";
|
||
Glean.newtab.opened.record({
|
||
newtab_visit_id: session.session_id,
|
||
source,
|
||
window_inner_height: data.window_inner_height,
|
||
window_inner_width: data.window_inner_width,
|
||
});
|
||
}
|
||
}
|
||
|
||
_beginObservingNewtabPingPrefs() {
|
||
Services.prefs.addObserver(ACTIVITY_STREAM_PREF_BRANCH, this);
|
||
|
||
for (const pref of Object.keys(NEWTAB_PING_PREFS)) {
|
||
const fullPrefName = ACTIVITY_STREAM_PREF_BRANCH + pref;
|
||
this._setNewtabPrefMetrics(fullPrefName, false);
|
||
}
|
||
Glean.pocket.isSignedIn.set(lazy.pktApi.isUserLoggedIn());
|
||
|
||
Services.prefs.addObserver(TOP_SITES_BLOCKED_SPONSORS_PREF, this);
|
||
this._setBlockedSponsorsMetrics();
|
||
|
||
Services.prefs.addObserver(TOPIC_SELECTION_SELECTED_TOPICS_PREF, this);
|
||
this._setTopicSelectionSelectedTopicsMetrics();
|
||
}
|
||
|
||
_stopObservingNewtabPingPrefs() {
|
||
Services.prefs.removeObserver(ACTIVITY_STREAM_PREF_BRANCH, this);
|
||
Services.prefs.removeObserver(TOP_SITES_BLOCKED_SPONSORS_PREF, this);
|
||
Services.prefs.removeObserver(TOPIC_SELECTION_SELECTED_TOPICS_PREF, this);
|
||
}
|
||
|
||
observe(subject, topic, data) {
|
||
if (data === TOP_SITES_BLOCKED_SPONSORS_PREF) {
|
||
this._setBlockedSponsorsMetrics();
|
||
} else if (data === TOPIC_SELECTION_SELECTED_TOPICS_PREF) {
|
||
this._setTopicSelectionSelectedTopicsMetrics();
|
||
} else {
|
||
this._setNewtabPrefMetrics(data, true);
|
||
}
|
||
}
|
||
|
||
_setNewtabPrefMetrics(fullPrefName, isChanged) {
|
||
const pref = fullPrefName.slice(ACTIVITY_STREAM_PREF_BRANCH.length);
|
||
if (!Object.hasOwn(NEWTAB_PING_PREFS, pref)) {
|
||
return;
|
||
}
|
||
const metric = NEWTAB_PING_PREFS[pref];
|
||
switch (Services.prefs.getPrefType(fullPrefName)) {
|
||
case Services.prefs.PREF_BOOL:
|
||
metric.set(Services.prefs.getBoolPref(fullPrefName));
|
||
break;
|
||
|
||
case Services.prefs.PREF_INT:
|
||
metric.set(Services.prefs.getIntPref(fullPrefName));
|
||
break;
|
||
}
|
||
if (isChanged) {
|
||
switch (fullPrefName) {
|
||
case `${ACTIVITY_STREAM_PREF_BRANCH}feeds.topsites`:
|
||
case `${ACTIVITY_STREAM_PREF_BRANCH}${PREF_SHOW_SPONSORED_TOPSITES}`:
|
||
Glean.topsites.prefChanged.record({
|
||
pref_name: fullPrefName,
|
||
new_value: Services.prefs.getBoolPref(fullPrefName),
|
||
});
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
_setBlockedSponsorsMetrics() {
|
||
let blocklist;
|
||
try {
|
||
blocklist = JSON.parse(
|
||
Services.prefs.getStringPref(TOP_SITES_BLOCKED_SPONSORS_PREF, "[]")
|
||
);
|
||
} catch (e) {}
|
||
if (blocklist) {
|
||
Glean.newtab.blockedSponsors.set(blocklist);
|
||
}
|
||
}
|
||
|
||
_setTopicSelectionSelectedTopicsMetrics() {
|
||
let topiclist;
|
||
try {
|
||
topiclist = Services.prefs.getStringPref(
|
||
TOPIC_SELECTION_SELECTED_TOPICS_PREF,
|
||
""
|
||
);
|
||
} catch (e) {}
|
||
if (topiclist) {
|
||
// Note: Beacuse Glean is expecting a string list, the
|
||
// value of the pref needs to be converted to an array
|
||
topiclist = topiclist.split(",").map(s => s.trim());
|
||
Glean.newtab.selectedTopics.set(topiclist);
|
||
}
|
||
}
|
||
|
||
uninit() {
|
||
this._stopObservingNewtabPingPrefs();
|
||
this.newtabContentPing.uninit();
|
||
|
||
try {
|
||
Services.obs.removeObserver(
|
||
this.browserOpenNewtabStart,
|
||
"browser-open-newtab-start"
|
||
);
|
||
} catch (e) {
|
||
// Operation can fail when uninit is called before
|
||
// init has finished setting up the observer
|
||
}
|
||
|
||
// TODO: Send any unfinished sessions
|
||
}
|
||
}
|