Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1435 insertions, 0 deletions

diff --git a/toolkit/components/telemetry/app/TelemetryControllerParent.sys.mjs b/toolkit/components/telemetry/app/TelemetryControllerParent.sys.mjs
new file mode 100644
index 0000000000..8008489242
--- /dev/null
+++ b/toolkit/components/telemetry/app/TelemetryControllerParent.sys.mjs
@@ -0,0 +1,1435 @@
+/* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
+/* 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/. */
+
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+import { AsyncShutdown } from "resource://gre/modules/AsyncShutdown.sys.mjs";
+import { PromiseUtils } from "resource://gre/modules/PromiseUtils.sys.mjs";
+import { DeferredTask } from "resource://gre/modules/DeferredTask.sys.mjs";
+
+import { TelemetryUtils } from "resource://gre/modules/TelemetryUtils.sys.mjs";
+import { TelemetryControllerBase } from "resource://gre/modules/TelemetryControllerBase.sys.mjs";
+
+const Utils = TelemetryUtils;
+
+const PING_FORMAT_VERSION = 4;
+
+// Delay before intializing telemetry (ms)
+const TELEMETRY_DELAY =
+  Services.prefs.getIntPref("toolkit.telemetry.initDelay", 60) * 1000;
+// Delay before initializing telemetry if we're testing (ms)
+const TELEMETRY_TEST_DELAY = 1;
+
+// How long to wait (ms) before sending the new profile ping on the first
+// run of a new profile.
+const NEWPROFILE_PING_DEFAULT_DELAY = 30 * 60 * 1000;
+
+// Ping types.
+const PING_TYPE_MAIN = "main";
+const PING_TYPE_DELETION_REQUEST = "deletion-request";
+const PING_TYPE_UNINSTALL = "uninstall";
+
+// Session ping reasons.
+const REASON_GATHER_PAYLOAD = "gather-payload";
+const REASON_GATHER_SUBSESSION_PAYLOAD = "gather-subsession-payload";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ClientID: "resource://gre/modules/ClientID.sys.mjs",
+  CoveragePing: "resource://gre/modules/CoveragePing.sys.mjs",
+  ProvenanceData: "resource:///modules/ProvenanceData.sys.mjs",
+  TelemetryArchive: "resource://gre/modules/TelemetryArchive.sys.mjs",
+  TelemetryEnvironment: "resource://gre/modules/TelemetryEnvironment.sys.mjs",
+  TelemetryEventPing: "resource://gre/modules/EventPing.sys.mjs",
+  TelemetryHealthPing: "resource://gre/modules/HealthPing.sys.mjs",
+  TelemetryModules: "resource://gre/modules/ModulesPing.sys.mjs",
+  TelemetryReportingPolicy:
+    "resource://gre/modules/TelemetryReportingPolicy.sys.mjs",
+  TelemetrySend: "resource://gre/modules/TelemetrySend.sys.mjs",
+  TelemetrySession: "resource://gre/modules/TelemetrySession.sys.mjs",
+  TelemetryStorage: "resource://gre/modules/TelemetryStorage.sys.mjs",
+  TelemetryUntrustedModulesPing:
+    "resource://gre/modules/UntrustedModulesPing.sys.mjs",
+  UninstallPing: "resource://gre/modules/UninstallPing.sys.mjs",
+  UpdatePing: "resource://gre/modules/UpdatePing.sys.mjs",
+  jwcrypto: "resource://services-crypto/jwcrypto.sys.mjs",
+});
+
+/**
+ * This is a policy object used to override behavior for testing.
+ */
+export var Policy = {
+  now: () => new Date(),
+  generatePingId: () => Utils.generateUUID(),
+  getCachedClientID: () => lazy.ClientID.getCachedClientID(),
+};
+
+export var TelemetryController = Object.freeze({
+  /**
+   * Used only for testing purposes.
+   */
+  testInitLogging() {
+    TelemetryControllerBase.configureLogging();
+  },
+
+  /**
+   * Used only for testing purposes.
+   */
+  testReset() {
+    return Impl.reset();
+  },
+
+  /**
+   * Used only for testing purposes.
+   */
+  testSetup() {
+    return Impl.setupTelemetry(true);
+  },
+
+  /**
+   * Used only for testing purposes.
+   */
+  testShutdown() {
+    return Impl.shutdown();
+  },
+
+  /**
+   * Used only for testing purposes.
+   */
+  testPromiseJsProbeRegistration() {
+    return Promise.resolve(Impl._probeRegistrationPromise);
+  },
+
+  /**
+   * Register 'dynamic builtin' probes from the JSON definition files.
+   * This is needed to support adding new probes in developer builds
+   * without rebuilding the whole codebase.
+   *
+   * This is not meant to be used outside of local developer builds.
+   */
+  testRegisterJsProbes() {
+    return Impl.registerJsProbes();
+  },
+
+  /**
+   * Used only for testing purposes.
+   */
+  testPromiseDeletionRequestPingSubmitted() {
+    return Promise.resolve(Impl._deletionRequestPingSubmittedPromise);
+  },
+
+  /**
+   * Send a notification.
+   */
+  observe(aSubject, aTopic, aData) {
+    return Impl.observe(aSubject, aTopic, aData);
+  },
+
+  /**
+   * Submit ping payloads to Telemetry. This will assemble a complete ping, adding
+   * environment data, client id and some general info.
+   * Depending on configuration, the ping will be sent to the server (immediately or later)
+   * and archived locally.
+   *
+   * To identify the different pings and to be able to query them pings have a type.
+   * A type is a string identifier that should be unique to the type ping that is being submitted,
+   * it should only contain alphanumeric characters and '-' for separation, i.e. satisfy:
+   * /^[a-z0-9][a-z0-9-]+[a-z0-9]$/i
+   *
+   * @param {String} aType The type of the ping.
+   * @param {Object} aPayload The actual data payload for the ping.
+   * @param {Object} [aOptions] Options object.
+   * @param {Boolean} [aOptions.addClientId=false] true if the ping should contain the client
+   *                  id, false otherwise.
+   * @param {Boolean} [aOptions.addEnvironment=false] true if the ping should contain the
+   *                  environment data.
+   * @param {Object}  [aOptions.overrideEnvironment=null] set to override the environment data.
+   * @param {Boolean} [aOptions.usePingSender=false] if true, send the ping using the PingSender.
+   * @param {String} [aOptions.overrideClientId=undefined] if set, override the
+   *                 client id to the provided value. Implies aOptions.addClientId=true.
+   * @returns {Promise} Test-only - a promise that resolves with the ping id once the ping is stored or sent.
+   */
+  submitExternalPing(aType, aPayload, aOptions = {}) {
+    aOptions.addClientId = aOptions.addClientId || false;
+    aOptions.addEnvironment = aOptions.addEnvironment || false;
+    aOptions.usePingSender = aOptions.usePingSender || false;
+
+    return Impl.submitExternalPing(aType, aPayload, aOptions);
+  },
+
+  /**
+   * Get the current session ping data as it would be sent out or stored.
+   *
+   * @param {bool} aSubsession Whether to get subsession data. Optional, defaults to false.
+   * @return {object} The current ping data if Telemetry is enabled, null otherwise.
+   */
+  getCurrentPingData(aSubsession = false) {
+    return Impl.getCurrentPingData(aSubsession);
+  },
+
+  /**
+   * Save a ping to disk.
+   *
+   * @param {String} aType The type of the ping.
+   * @param {Object} aPayload The actual data payload for the ping.
+   * @param {Object} [aOptions] Options object.
+   * @param {Boolean} [aOptions.addClientId=false] true if the ping should contain the client
+   *                  id, false otherwise.
+   * @param {Boolean} [aOptions.addEnvironment=false] true if the ping should contain the
+   *                  environment data.
+   * @param {Boolean} [aOptions.overwrite=false] true overwrites a ping with the same name,
+   *                  if found.
+   * @param {Object}  [aOptions.overrideEnvironment=null] set to override the environment data.
+   * @param {String} [aOptions.overrideClientId=undefined] if set, override the
+   *                 client id to the provided value. Implies aOptions.addClientId=true.
+   *
+   * @returns {Promise} A promise that resolves with the ping id when the ping is saved to
+   *                    disk.
+   */
+  addPendingPing(aType, aPayload, aOptions = {}) {
+    let options = aOptions;
+    options.addClientId = aOptions.addClientId || false;
+    options.addEnvironment = aOptions.addEnvironment || false;
+    options.overwrite = aOptions.overwrite || false;
+
+    return Impl.addPendingPing(aType, aPayload, options);
+  },
+
+  /**
+   * Check if we have an aborted-session ping from a previous session.
+   * If so, submit and then remove it.
+   *
+   * @return {Promise} Promise that is resolved when the ping is saved.
+   */
+  checkAbortedSessionPing() {
+    return Impl.checkAbortedSessionPing();
+  },
+
+  /**
+   * Save an aborted-session ping to disk without adding it to the pending pings.
+   *
+   * @param {Object} aPayload The ping payload data.
+   * @return {Promise} Promise that is resolved when the ping is saved.
+   */
+  saveAbortedSessionPing(aPayload) {
+    return Impl.saveAbortedSessionPing(aPayload);
+  },
+
+  /**
+   * Remove the aborted-session ping if any exists.
+   *
+   * @return {Promise} Promise that is resolved when the ping was removed.
+   */
+  removeAbortedSessionPing() {
+    return Impl.removeAbortedSessionPing();
+  },
+
+  /**
+   * Create an uninstall ping and write it to disk, replacing any already present.
+   * This is stored independently from other pings, and only read by
+   * the Windows uninstaller.
+   *
+   * WINDOWS ONLY, does nothing and resolves immediately on other platforms.
+   *
+   * @return {Promise} Resolved when the ping has been saved.
+   */
+  saveUninstallPing() {
+    return Impl.saveUninstallPing();
+  },
+
+  /**
+   * Allows the sync ping to tell the controller that it is initializing, so
+   * should be included in the orderly shutdown process.
+   *
+   * @param {Function} aFnShutdown The function to call as telemetry shuts down.
+
+   */
+  registerSyncPingShutdown(afnShutdown) {
+    Impl.registerSyncPingShutdown(afnShutdown);
+  },
+
+  /**
+   * Allows waiting for TelemetryControllers delayed initialization to complete.
+   * The returned promise is guaranteed to resolve before TelemetryController is shutting down.
+   * @return {Promise} Resolved when delayed TelemetryController initialization completed.
+   */
+  promiseInitialized() {
+    return Impl.promiseInitialized();
+  },
+});
+
+var Impl = {
+  _initialized: false,
+  _initStarted: false, // Whether we started setting up TelemetryController.
+  _shuttingDown: false, // Whether the browser is shutting down.
+  _shutDown: false, // Whether the browser has shut down.
+  _logger: null,
+  _prevValues: {},
+  // The previous build ID, if this is the first run with a new build.
+  // Undefined if this is not the first run, or the previous build ID is unknown.
+  _previousBuildID: undefined,
+  _clientID: null,
+  // A task performing delayed initialization
+  _delayedInitTask: null,
+  // The deferred promise resolved when the initialization task completes.
+  _delayedInitTaskDeferred: null,
+
+  // This is a public barrier Telemetry clients can use to add blockers to the shutdown
+  // of TelemetryController.
+  // After this barrier, clients can not submit Telemetry pings anymore.
+  _shutdownBarrier: new AsyncShutdown.Barrier(
+    "TelemetryController: Waiting for clients."
+  ),
+  // This state is included in the async shutdown annotation for crash pings and reports.
+  _shutdownState: "Shutdown not started.",
+  // This is a private barrier blocked by pending async ping activity (sending & saving).
+  _connectionsBarrier: new AsyncShutdown.Barrier(
+    "TelemetryController: Waiting for pending ping activity"
+  ),
+  // This is true when running in the test infrastructure.
+  _testMode: false,
+  // The task performing the delayed sending of the "new-profile" ping.
+  _delayedNewPingTask: null,
+  // The promise used to wait for the JS probe registration (dynamic builtin).
+  _probeRegistrationPromise: null,
+  // The promise of any outstanding task sending the "deletion-request" ping.
+  _deletionRequestPingSubmittedPromise: null,
+  // A function to shutdown the sync/fxa ping, or null if that ping has not
+  // self-initialized.
+  _fnSyncPingShutdown: null,
+
+  get _log() {
+    return TelemetryControllerBase.log;
+  },
+
+  /**
+   * Get the data for the "application" section of the ping.
+   */
+  _getApplicationSection() {
+    // Querying architecture and update channel can throw. Make sure to recover and null
+    // those fields.
+    let arch = null;
+    try {
+      arch = Services.sysinfo.get("arch");
+    } catch (e) {
+      this._log.trace(
+        "_getApplicationSection - Unable to get system architecture.",
+        e
+      );
+    }
+
+    let updateChannel = null;
+    try {
+      updateChannel = Utils.getUpdateChannel();
+    } catch (e) {
+      this._log.trace(
+        "_getApplicationSection - Unable to get update channel.",
+        e
+      );
+    }
+
+    return {
+      architecture: arch,
+      buildId: Services.appinfo.appBuildID,
+      name: Services.appinfo.name,
+      version: Services.appinfo.version,
+      displayVersion: AppConstants.MOZ_APP_VERSION_DISPLAY,
+      vendor: Services.appinfo.vendor,
+      platformVersion: Services.appinfo.platformVersion,
+      xpcomAbi: Services.appinfo.XPCOMABI,
+      channel: updateChannel,
+    };
+  },
+
+  /**
+   * Assemble a complete ping following the common ping format specification.
+   *
+   * @param {String} aType The type of the ping.
+   * @param {Object} aPayload The actual data payload for the ping.
+   * @param {Object} aOptions Options object.
+   * @param {Boolean} aOptions.addClientId true if the ping should contain the client
+   *                  id, false otherwise.
+   * @param {Boolean} aOptions.addEnvironment true if the ping should contain the
+   *                  environment data.
+   * @param {Object}  [aOptions.overrideEnvironment=null] set to override the environment data.
+   * @param {String} [aOptions.overrideClientId=undefined] if set, override the
+   *                 client id to the provided value. Implies aOptions.addClientId=true.
+   * @param {Boolean} [aOptions.useEncryption=false] if true, encrypt data client-side before sending.
+   * @param {Object}  [aOptions.publicKey=null] the public key to use if encryption is enabled (JSON Web Key).
+   * @param {String}  [aOptions.encryptionKeyId=null] the public key ID to use if encryption is enabled.
+   * @param {String}  [aOptions.studyName=null] the study name to use.
+   * @param {String}  [aOptions.schemaName=null] the schema name to use if encryption is enabled.
+   * @param {String}  [aOptions.schemaNamespace=null] the schema namespace to use if encryption is enabled.
+   * @param {String}  [aOptions.schemaVersion=null] the schema version to use if encryption is enabled.
+   * @param {Boolean} [aOptions.addPioneerId=false] true if the ping should contain the Pioneer id, false otherwise.
+   * @param {Boolean} [aOptions.overridePioneerId=undefined] if set, override the
+   *                  pioneer id to the provided value. Only works if aOptions.addPioneerId=true.
+   * @returns {Object} An object that contains the assembled ping data.
+   */
+  assemblePing: function assemblePing(aType, aPayload, aOptions = {}) {
+    this._log.trace(
+      "assemblePing - Type " + aType + ", aOptions " + JSON.stringify(aOptions)
+    );
+
+    // Clone the payload data so we don't race against unexpected changes in subobjects that are
+    // still referenced by other code.
+    // We can't trust all callers to do this properly on their own.
+    let payload = Cu.cloneInto(aPayload, {});
+
+    // Fill the common ping fields.
+    let pingData = {
+      type: aType,
+      id: Policy.generatePingId(),
+      creationDate: Policy.now().toISOString(),
+      version: PING_FORMAT_VERSION,
+      application: this._getApplicationSection(),
+      payload,
+    };
+
+    if (aOptions.addClientId || aOptions.overrideClientId) {
+      pingData.clientId = aOptions.overrideClientId || this._clientID;
+    }
+
+    if (aOptions.addEnvironment) {
+      pingData.environment =
+        aOptions.overrideEnvironment ||
+        lazy.TelemetryEnvironment.currentEnvironment;
+    }
+
+    return pingData;
+  },
+
+  /**
+   * Track any pending ping send and save tasks through the promise passed here.
+   * This is needed to block shutdown on any outstanding ping activity.
+   */
+  _trackPendingPingTask(aPromise) {
+    this._connectionsBarrier.client.addBlocker(
+      "Waiting for ping task",
+      aPromise
+    );
+  },
+
+  /**
+   * Internal function to assemble a complete ping, adding environment data, client id
+   * and some general info. This waits on the client id to be loaded/generated if it's
+   * not yet available. Note that this function is synchronous unless we need to load
+   * the client id.
+   * Depending on configuration, the ping will be sent to the server (immediately or later)
+   * and archived locally.
+   *
+   * @param {String} aType The type of the ping.
+   * @param {Object} aPayload The actual data payload for the ping.
+   * @param {Object} [aOptions] Options object.
+   * @param {Boolean} [aOptions.addClientId=false] true if the ping should contain the client
+   *                  id, false otherwise.
+   * @param {Boolean} [aOptions.addEnvironment=false] true if the ping should contain the
+   *                  environment data.
+   * @param {Object}  [aOptions.overrideEnvironment=null] set to override the environment data.
+   * @param {Boolean} [aOptions.usePingSender=false] if true, send the ping using the PingSender.
+   * @param {Boolean} [aOptions.useEncryption=false] if true, encrypt data client-side before sending.
+   * @param {Object}  [aOptions.publicKey=null] the public key to use if encryption is enabled (JSON Web Key).
+   * @param {String}  [aOptions.encryptionKeyId=null] the public key ID to use if encryption is enabled.
+   * @param {String}  [aOptions.studyName=null] the study name to use.
+   * @param {String}  [aOptions.schemaName=null] the schema name to use if encryption is enabled.
+   * @param {String}  [aOptions.schemaNamespace=null] the schema namespace to use if encryption is enabled.
+   * @param {String}  [aOptions.schemaVersion=null] the schema version to use if encryption is enabled.
+   * @param {Boolean} [aOptions.addPioneerId=false] true if the ping should contain the Pioneer id, false otherwise.
+   * @param {Boolean} [aOptions.overridePioneerId=undefined] if set, override the
+   *                  pioneer id to the provided value. Only works if aOptions.addPioneerId=true.
+   * @param {String} [aOptions.overrideClientId=undefined] if set, override the
+   *                 client id to the provided value. Implies aOptions.addClientId=true.
+   * @returns {Promise} Test-only - a promise that is resolved with the ping id once the ping is stored or sent.
+   */
+  async _submitPingLogic(aType, aPayload, aOptions) {
+    // Make sure to have a clientId if we need one. This cover the case of submitting
+    // a ping early during startup, before Telemetry is initialized, if no client id was
+    // cached.
+    if (!this._clientID && aOptions.addClientId && !aOptions.overrideClientId) {
+      this._log.trace("_submitPingLogic - Waiting on client id");
+      Services.telemetry
+        .getHistogramById("TELEMETRY_PING_SUBMISSION_WAITING_CLIENTID")
+        .add();
+      // We can safely call |getClientID| here and during initialization: we would still
+      // spawn and return one single loading task.
+      this._clientID = await lazy.ClientID.getClientID();
+    }
+
+    let pingData = this.assemblePing(aType, aPayload, aOptions);
+    this._log.trace("submitExternalPing - ping assembled, id: " + pingData.id);
+
+    if (aOptions.useEncryption === true) {
+      try {
+        if (!aOptions.publicKey) {
+          throw new Error("Public key is required when using encryption.");
+        }
+
+        if (
+          !(
+            aOptions.schemaName &&
+            aOptions.schemaNamespace &&
+            aOptions.schemaVersion
+          )
+        ) {
+          throw new Error(
+            "Schema name, namespace, and version are required when using encryption."
+          );
+        }
+
+        const payload = {};
+        payload.encryptedData = await lazy.jwcrypto.generateJWE(
+          aOptions.publicKey,
+          new TextEncoder().encode(JSON.stringify(aPayload))
+        );
+
+        payload.schemaVersion = aOptions.schemaVersion;
+        payload.schemaName = aOptions.schemaName;
+        payload.schemaNamespace = aOptions.schemaNamespace;
+
+        payload.encryptionKeyId = aOptions.encryptionKeyId;
+
+        if (aOptions.addPioneerId === true) {
+          if (aOptions.overridePioneerId) {
+            // The caller provided a substitute id, let's use that
+            // instead of querying the pref.
+            payload.pioneerId = aOptions.overridePioneerId;
+          } else {
+            // This will throw if there is no pioneer ID set.
+            payload.pioneerId = Services.prefs.getStringPref(
+              "toolkit.telemetry.pioneerId"
+            );
+          }
+          payload.studyName = aOptions.studyName;
+        }
+
+        pingData.payload = payload;
+      } catch (e) {
+        this._log.error("_submitPingLogic - Unable to encrypt ping", e);
+        // Do not attempt to continue
+        throw e;
+      }
+    }
+
+    // Always persist the pings if we are allowed to. We should not yield on any of the
+    // following operations to keep this function synchronous for the majority of the calls.
+    let archivePromise = lazy.TelemetryArchive.promiseArchivePing(
+      pingData
+    ).catch(e =>
+      this._log.error(
+        "submitExternalPing - Failed to archive ping " + pingData.id,
+        e
+      )
+    );
+    let p = [archivePromise];
+
+    p.push(
+      lazy.TelemetrySend.submitPing(pingData, {
+        usePingSender: aOptions.usePingSender,
+      })
+    );
+
+    return Promise.all(p).then(() => pingData.id);
+  },
+
+  /**
+   * Submit ping payloads to Telemetry.
+   *
+   * @param {String} aType The type of the ping.
+   * @param {Object} aPayload The actual data payload for the ping.
+   * @param {Object} [aOptions] Options object.
+   * @param {Boolean} [aOptions.addClientId=false] true if the ping should contain the client
+   *                  id, false otherwise.
+   * @param {Boolean} [aOptions.addEnvironment=false] true if the ping should contain the
+   *                  environment data.
+   * @param {Object}  [aOptions.overrideEnvironment=null] set to override the environment data.
+   * @param {Boolean} [aOptions.usePingSender=false] if true, send the ping using the PingSender.
+   * @param {Boolean} [aOptions.useEncryption=false] if true, encrypt data client-side before sending.
+   * @param {Object}  [aOptions.publicKey=null] the public key to use if encryption is enabled (JSON Web Key).
+   * @param {String}  [aOptions.encryptionKeyId=null] the public key ID to use if encryption is enabled.
+   * @param {String}  [aOptions.studyName=null] the study name to use.
+   * @param {String}  [aOptions.schemaName=null] the schema name to use if encryption is enabled.
+   * @param {String}  [aOptions.schemaNamespace=null] the schema namespace to use if encryption is enabled.
+   * @param {String}  [aOptions.schemaVersion=null] the schema version to use if encryption is enabled.
+   * @param {Boolean} [aOptions.addPioneerId=false] true if the ping should contain the Pioneer id, false otherwise.
+   * @param {Boolean} [aOptions.overridePioneerId=undefined] if set, override the
+   *                  pioneer id to the provided value. Only works if aOptions.addPioneerId=true.
+   * @param {String} [aOptions.overrideClientId=undefined] if set, override the
+   *                 client id to the provided value. Implies aOptions.addClientId=true.
+   * @returns {Promise} Test-only - a promise that is resolved with the ping id once the ping is stored or sent.
+   */
+  submitExternalPing: function send(aType, aPayload, aOptions) {
+    this._log.trace(
+      "submitExternalPing - type: " +
+        aType +
+        ", aOptions: " +
+        JSON.stringify(aOptions)
+    );
+
+    // Reject pings sent after shutdown.
+    if (this._shutDown) {
+      const errorMessage =
+        "submitExternalPing - Submission is not allowed after shutdown, discarding ping of type: " +
+        aType;
+      this._log.error(errorMessage);
+      return Promise.reject(new Error(errorMessage));
+    }
+
+    // Enforce the type string to only contain sane characters.
+    const typeUuid = /^[a-z0-9][a-z0-9-]+[a-z0-9]$/i;
+    if (!typeUuid.test(aType)) {
+      this._log.error("submitExternalPing - invalid ping type: " + aType);
+      let histogram = Services.telemetry.getKeyedHistogramById(
+        "TELEMETRY_INVALID_PING_TYPE_SUBMITTED"
+      );
+      histogram.add(aType, 1);
+      return Promise.reject(new Error("Invalid type string submitted."));
+    }
+    // Enforce that the payload is an object.
+    if (
+      aPayload === null ||
+      typeof aPayload !== "object" ||
+      Array.isArray(aPayload)
+    ) {
+      this._log.error(
+        "submitExternalPing - invalid payload type: " + typeof aPayload
+      );
+      let histogram = Services.telemetry.getHistogramById(
+        "TELEMETRY_INVALID_PAYLOAD_SUBMITTED"
+      );
+      histogram.add(1);
+      return Promise.reject(new Error("Invalid payload type submitted."));
+    }
+
+    let promise = this._submitPingLogic(aType, aPayload, aOptions);
+    this._trackPendingPingTask(promise);
+    return promise;
+  },
+
+  /**
+   * Save a ping to disk.
+   *
+   * @param {String} aType The type of the ping.
+   * @param {Object} aPayload The actual data payload for the ping.
+   * @param {Object} aOptions Options object.
+   * @param {Boolean} aOptions.addClientId true if the ping should contain the client id,
+   *                  false otherwise.
+   * @param {Boolean} aOptions.addEnvironment true if the ping should contain the
+   *                  environment data.
+   * @param {Boolean} aOptions.overwrite true overwrites a ping with the same name, if found.
+   * @param {Object}  [aOptions.overrideEnvironment=null] set to override the environment data.
+   * @param {String} [aOptions.overrideClientId=undefined] if set, override the
+   *                 client id to the provided value. Implies aOptions.addClientId=true.
+   *
+   * @returns {Promise} A promise that resolves with the ping id when the ping is saved to
+   *                    disk.
+   */
+  addPendingPing: function addPendingPing(aType, aPayload, aOptions) {
+    this._log.trace(
+      "addPendingPing - Type " +
+        aType +
+        ", aOptions " +
+        JSON.stringify(aOptions)
+    );
+
+    let pingData = this.assemblePing(aType, aPayload, aOptions);
+
+    let savePromise = lazy.TelemetryStorage.savePendingPing(pingData);
+    let archivePromise = lazy.TelemetryArchive.promiseArchivePing(
+      pingData
+    ).catch(e => {
+      this._log.error(
+        "addPendingPing - Failed to archive ping " + pingData.id,
+        e
+      );
+    });
+
+    // Wait for both the archiving and ping persistence to complete.
+    let promises = [savePromise, archivePromise];
+    return Promise.all(promises).then(() => pingData.id);
+  },
+
+  /**
+   * Check whether we have an aborted-session ping. If so add it to the pending pings and archive it.
+   *
+   * @return {Promise} Promise that is resolved when the ping is submitted and archived.
+   */
+  async checkAbortedSessionPing() {
+    let ping = await lazy.TelemetryStorage.loadAbortedSessionPing();
+    this._log.trace(
+      "checkAbortedSessionPing - found aborted-session ping: " + !!ping
+    );
+    if (!ping) {
+      return;
+    }
+
+    try {
+      // Previous aborted-session might have been with a canary client ID.
+      // Don't send it.
+      if (ping.clientId != Utils.knownClientID) {
+        await lazy.TelemetryStorage.addPendingPing(ping);
+        await lazy.TelemetryArchive.promiseArchivePing(ping);
+      }
+    } catch (e) {
+      this._log.error(
+        "checkAbortedSessionPing - Unable to add the pending ping",
+        e
+      );
+    } finally {
+      await lazy.TelemetryStorage.removeAbortedSessionPing();
+    }
+  },
+
+  /**
+   * Save an aborted-session ping to disk without adding it to the pending pings.
+   *
+   * @param {Object} aPayload The ping payload data.
+   * @return {Promise} Promise that is resolved when the ping is saved.
+   */
+  saveAbortedSessionPing(aPayload) {
+    this._log.trace("saveAbortedSessionPing");
+    const options = { addClientId: true, addEnvironment: true };
+    const pingData = this.assemblePing(PING_TYPE_MAIN, aPayload, options);
+    return lazy.TelemetryStorage.saveAbortedSessionPing(pingData);
+  },
+
+  removeAbortedSessionPing() {
+    return lazy.TelemetryStorage.removeAbortedSessionPing();
+  },
+
+  async saveUninstallPing() {
+    if (AppConstants.platform != "win") {
+      return undefined;
+    }
+
+    this._log.trace("saveUninstallPing");
+
+    let payload = {};
+    try {
+      payload.otherInstalls = lazy.UninstallPing.getOtherInstallsCount();
+      this._log.info(
+        "saveUninstallPing - otherInstalls",
+        payload.otherInstalls
+      );
+    } catch (e) {
+      this._log.warn("saveUninstallPing - getOtherInstallCount failed", e);
+    }
+    const options = { addClientId: true, addEnvironment: true };
+    const pingData = this.assemblePing(PING_TYPE_UNINSTALL, payload, options);
+
+    return lazy.TelemetryStorage.saveUninstallPing(pingData);
+  },
+
+  /**
+   * This triggers basic telemetry initialization and schedules a full initialized for later
+   * for performance reasons.
+   *
+   * This delayed initialization means TelemetryController init can be in the following states:
+   * 1) setupTelemetry was never called
+   * or it was called and
+   *   2) _delayedInitTask was scheduled, but didn't run yet.
+   *   3) _delayedInitTask is currently running.
+   *   4) _delayedInitTask finished running and is nulled out.
+   *
+   * @return {Promise} Resolved when TelemetryController and TelemetrySession are fully
+   *                   initialized. This is only used in tests.
+   */
+  setupTelemetry: function setupTelemetry(testing) {
+    this._initStarted = true;
+    this._shuttingDown = false;
+    this._shutDown = false;
+    this._testMode = testing;
+
+    this._log.trace("setupTelemetry");
+
+    if (this._delayedInitTask) {
+      this._log.error("setupTelemetry - init task already running");
+      return this._delayedInitTaskDeferred.promise;
+    }
+
+    if (this._initialized && !this._testMode) {
+      this._log.error("setupTelemetry - already initialized");
+      return Promise.resolve();
+    }
+
+    // Enable adding scalars in artifact builds and build faster modes.
+    // The function is async: we intentionally don't wait for it to complete
+    // as we don't want to delay startup.
+    this._probeRegistrationPromise = this.registerJsProbes();
+
+    // This will trigger displaying the datachoices infobar.
+    lazy.TelemetryReportingPolicy.setup();
+
+    if (!TelemetryControllerBase.enableTelemetryRecording()) {
+      this._log.config(
+        "setupChromeProcess - Telemetry recording is disabled, skipping Chrome process setup."
+      );
+      return Promise.resolve();
+    }
+
+    this._attachObservers();
+
+    // Perform a lightweight, early initialization for the component, just registering
+    // a few observers and initializing the session.
+    lazy.TelemetrySession.earlyInit(this._testMode);
+    Services.telemetry.earlyInit();
+
+    // Annotate crash reports so that we get pings for startup crashes
+    lazy.TelemetrySend.earlyInit();
+
+    // For very short session durations, we may never load the client
+    // id from disk.
+    // We try to cache it in prefs to avoid this, even though this may
+    // lead to some stale client ids.
+    this._clientID = lazy.ClientID.getCachedClientID();
+
+    // Init the update ping telemetry as early as possible. This won't have
+    // an impact on startup.
+    lazy.UpdatePing.earlyInit();
+
+    // Delay full telemetry initialization to give the browser time to
+    // run various late initializers. Otherwise our gathered memory
+    // footprint and other numbers would be too optimistic.
+    this._delayedInitTaskDeferred = PromiseUtils.defer();
+    this._delayedInitTask = new DeferredTask(
+      async () => {
+        try {
+          // TODO: This should probably happen after all the delayed init here.
+          this._initialized = true;
+          await lazy.TelemetryEnvironment.delayedInit();
+
+          // Load the ClientID.
+          this._clientID = await lazy.ClientID.getClientID();
+
+          // Fix-up a canary client ID if detected.
+          const uploadEnabled = Services.prefs.getBoolPref(
+            TelemetryUtils.Preferences.FhrUploadEnabled,
+            false
+          );
+          if (uploadEnabled && this._clientID == Utils.knownClientID) {
+            this._log.trace(
+              "Upload enabled, but got canary client ID. Resetting."
+            );
+            await lazy.ClientID.removeClientID();
+            this._clientID = await lazy.ClientID.getClientID();
+          } else if (!uploadEnabled && this._clientID != Utils.knownClientID) {
+            this._log.trace(
+              "Upload disabled, but got a valid client ID. Setting canary client ID."
+            );
+            await lazy.ClientID.setCanaryClientID();
+            this._clientID = await lazy.ClientID.getClientID();
+          }
+
+          await lazy.TelemetrySend.setup(this._testMode);
+
+          // Perform TelemetrySession delayed init.
+          await lazy.TelemetrySession.delayedInit();
+          await Services.telemetry.delayedInit();
+
+          if (
+            Services.prefs.getBoolPref(
+              TelemetryUtils.Preferences.NewProfilePingEnabled,
+              false
+            ) &&
+            !lazy.TelemetrySession.newProfilePingSent
+          ) {
+            // Kick off the scheduling of the new-profile ping.
+            this.scheduleNewProfilePing();
+          }
+
+          // Purge the pings archive by removing outdated pings. We don't wait for
+          // this task to complete, but TelemetryStorage blocks on it during
+          // shutdown.
+          lazy.TelemetryStorage.runCleanPingArchiveTask();
+
+          // Now that FHR/healthreporter is gone, make sure to remove FHR's DB from
+          // the profile directory. This is a temporary measure that we should drop
+          // in the future.
+          lazy.TelemetryStorage.removeFHRDatabase();
+
+          // The init sequence is forced to run on shutdown for short sessions and
+          // we don't want to start TelemetryModules as the timer registration will fail.
+          if (!this._shuttingDown) {
+            // Report the modules loaded in the Firefox process.
+            lazy.TelemetryModules.start();
+
+            // Send coverage ping.
+            await lazy.CoveragePing.startup();
+
+            // Start the untrusted modules ping, which reports events where
+            // untrusted modules were loaded into the Firefox process.
+            if (AppConstants.platform == "win") {
+              lazy.TelemetryUntrustedModulesPing.start();
+            }
+          }
+
+          lazy.TelemetryEventPing.startup();
+
+          if (uploadEnabled) {
+            await this.saveUninstallPing().catch(e =>
+              this._log.warn("_delayedInitTask - saveUninstallPing failed", e)
+            );
+          } else {
+            await lazy.TelemetryStorage.removeUninstallPings().catch(e =>
+              this._log.warn("_delayedInitTask - saveUninstallPing", e)
+            );
+          }
+
+          this._delayedInitTaskDeferred.resolve();
+        } catch (e) {
+          this._delayedInitTaskDeferred.reject(e);
+        } finally {
+          this._delayedInitTask = null;
+        }
+      },
+      this._testMode ? TELEMETRY_TEST_DELAY : TELEMETRY_DELAY,
+      this._testMode ? 0 : undefined
+    );
+
+    IOUtils.sendTelemetry.addBlocker(
+      "TelemetryController: shutting down",
+      () => this.shutdown(),
+      () => this._getState()
+    );
+
+    this._delayedInitTask.arm();
+    return this._delayedInitTaskDeferred.promise;
+  },
+
+  // Do proper shutdown waiting and cleanup.
+  async _cleanupOnShutdown() {
+    if (!this._initialized) {
+      return;
+    }
+
+    this._detachObservers();
+
+    // Now do an orderly shutdown.
+    try {
+      if (this._delayedNewPingTask) {
+        await this._delayedNewPingTask.finalize();
+      }
+
+      lazy.UpdatePing.shutdown();
+
+      lazy.TelemetryEventPing.shutdown();
+
+      // Shutdown the sync ping if it is initialized - this is likely, but not
+      // guaranteed, to submit a "shutdown" sync ping.
+      if (this._fnSyncPingShutdown) {
+        this._fnSyncPingShutdown();
+      }
+
+      // Stop the datachoices infobar display.
+      lazy.TelemetryReportingPolicy.shutdown();
+      lazy.TelemetryEnvironment.shutdown();
+
+      // Stop any ping sending.
+      await lazy.TelemetrySend.shutdown();
+
+      // Send latest data.
+      await lazy.TelemetryHealthPing.shutdown();
+
+      await lazy.TelemetrySession.shutdown();
+      await Services.telemetry.shutdown();
+
+      // First wait for clients processing shutdown.
+      await this._shutdownBarrier.wait();
+
+      // ... and wait for any outstanding async ping activity.
+      await this._connectionsBarrier.wait();
+
+      if (AppConstants.platform !== "android") {
+        // No PingSender on Android.
+        lazy.TelemetrySend.flushPingSenderBatch();
+      }
+
+      // Perform final shutdown operations.
+      await lazy.TelemetryStorage.shutdown();
+    } finally {
+      // Reset state.
+      this._initialized = false;
+      this._initStarted = false;
+      this._shutDown = true;
+    }
+  },
+
+  shutdown() {
+    this._log.trace("shutdown");
+
+    this._shuttingDown = true;
+
+    // We can be in one the following states here:
+    // 1) setupTelemetry was never called
+    // or it was called and
+    //   2) _delayedInitTask was scheduled, but didn't run yet.
+    //   3) _delayedInitTask is running now.
+    //   4) _delayedInitTask finished running already.
+
+    // This handles 1).
+    if (!this._initStarted) {
+      this._shutDown = true;
+      return Promise.resolve();
+    }
+
+    // This handles 4).
+    if (!this._delayedInitTask) {
+      // We already ran the delayed initialization.
+      return this._cleanupOnShutdown();
+    }
+
+    // This handles 2) and 3).
+    return this._delayedInitTask
+      .finalize()
+      .then(() => this._cleanupOnShutdown());
+  },
+
+  /**
+   * This observer drives telemetry.
+   */
+  observe(aSubject, aTopic, aData) {
+    // The logger might still be not available at this point.
+    if (aTopic == "profile-after-change") {
+      // If we don't have a logger, we need to make sure |Log.repository.getLogger()| is
+      // called before |getLoggerWithMessagePrefix|. Otherwise logging won't work.
+      TelemetryControllerBase.configureLogging();
+    }
+
+    this._log.trace(`observe - ${aTopic} notified.`);
+
+    switch (aTopic) {
+      case "profile-after-change":
+        // profile-after-change is only registered for chrome processes.
+        return this.setupTelemetry();
+      case "nsPref:changed":
+        if (aData == TelemetryUtils.Preferences.FhrUploadEnabled) {
+          return this._onUploadPrefChange();
+        }
+    }
+    return undefined;
+  },
+
+  /**
+   * Register the sync ping's shutdown handler.
+   */
+  registerSyncPingShutdown(fnShutdown) {
+    if (this._fnSyncPingShutdown) {
+      throw new Error("The sync ping shutdown handler is already registered.");
+    }
+    this._fnSyncPingShutdown = fnShutdown;
+  },
+
+  /**
+   * Get an object describing the current state of this module for AsyncShutdown diagnostics.
+   */
+  _getState() {
+    return {
+      initialized: this._initialized,
+      initStarted: this._initStarted,
+      haveDelayedInitTask: !!this._delayedInitTask,
+      shutdownBarrier: this._shutdownBarrier.state,
+      connectionsBarrier: this._connectionsBarrier.state,
+      sendModule: lazy.TelemetrySend.getShutdownState(),
+      haveDelayedNewProfileTask: !!this._delayedNewPingTask,
+    };
+  },
+
+  /**
+   * Called whenever the FHR Upload preference changes (e.g. when user disables FHR from
+   * the preferences panel), this triggers sending the "deletion-request" ping.
+   */
+  _onUploadPrefChange() {
+    const uploadEnabled = Services.prefs.getBoolPref(
+      TelemetryUtils.Preferences.FhrUploadEnabled,
+      false
+    );
+    if (uploadEnabled) {
+      this._log.trace(
+        "_onUploadPrefChange - upload was enabled again. Resetting client ID"
+      );
+
+      // Delete cached client ID immediately, so other usage is forced to refetch it.
+      this._clientID = null;
+
+      // Generate a new client ID and make sure this module uses the new version
+      let p = (async () => {
+        await lazy.ClientID.removeClientID();
+        let id = await lazy.ClientID.getClientID();
+        this._clientID = id;
+        Services.telemetry.scalarSet("telemetry.data_upload_optin", true);
+
+        await this.saveUninstallPing().catch(e =>
+          this._log.warn("_onUploadPrefChange - saveUninstallPing failed", e)
+        );
+      })();
+
+      this._shutdownBarrier.client.addBlocker(
+        "TelemetryController: resetting client ID after data upload was enabled",
+        p
+      );
+
+      return;
+    }
+
+    let p = (async () => {
+      try {
+        // 1. Cancel the current pings.
+        // 2. Clear unpersisted pings
+        await lazy.TelemetrySend.clearCurrentPings();
+
+        // 3. Remove all pending pings
+        await lazy.TelemetryStorage.removeAppDataPings();
+        await lazy.TelemetryStorage.runRemovePendingPingsTask();
+        await lazy.TelemetryStorage.removeUninstallPings();
+      } catch (e) {
+        this._log.error(
+          "_onUploadPrefChange - error clearing pending pings",
+          e
+        );
+      } finally {
+        // 4. Reset session and subsession counter
+        lazy.TelemetrySession.resetSubsessionCounter();
+
+        // 5. Collect any additional identifiers we want to send in the
+        // deletion request.
+        const scalars = Services.telemetry.getSnapshotForScalars(
+          "deletion-request",
+          /* clear */ true
+        );
+
+        // 6. Set ClientID to a known value
+        let oldClientId = await lazy.ClientID.getClientID();
+        await lazy.ClientID.setCanaryClientID();
+        this._clientID = await lazy.ClientID.getClientID();
+
+        // 7. Send the deletion-request ping.
+        this._log.trace("_onUploadPrefChange - Sending deletion-request ping.");
+        this.submitExternalPing(
+          PING_TYPE_DELETION_REQUEST,
+          { scalars },
+          { overrideClientId: oldClientId }
+        );
+        this._deletionRequestPingSubmittedPromise = null;
+      }
+    })();
+
+    this._deletionRequestPingSubmittedPromise = p;
+    this._shutdownBarrier.client.addBlocker(
+      "TelemetryController: removing pending pings after data upload was disabled",
+      p
+    );
+
+    Services.obs.notifyObservers(
+      null,
+      TelemetryUtils.TELEMETRY_UPLOAD_DISABLED_TOPIC
+    );
+  },
+
+  QueryInterface: ChromeUtils.generateQI(["nsISupportsWeakReference"]),
+
+  _attachObservers() {
+    if (TelemetryControllerBase.IS_UNIFIED_TELEMETRY) {
+      // Watch the FHR upload setting to trigger "deletion-request" pings.
+      Services.prefs.addObserver(
+        TelemetryUtils.Preferences.FhrUploadEnabled,
+        this,
+        true
+      );
+    }
+  },
+
+  /**
+   * Remove the preference observer to avoid leaks.
+   */
+  _detachObservers() {
+    if (TelemetryControllerBase.IS_UNIFIED_TELEMETRY) {
+      Services.prefs.removeObserver(
+        TelemetryUtils.Preferences.FhrUploadEnabled,
+        this
+      );
+    }
+  },
+
+  /**
+   * Allows waiting for TelemetryControllers delayed initialization to complete.
+   * This will complete before TelemetryController is shutting down.
+   * @return {Promise} Resolved when delayed TelemetryController initialization completed.
+   */
+  promiseInitialized() {
+    return this._delayedInitTaskDeferred.promise;
+  },
+
+  getCurrentPingData(aSubsession) {
+    this._log.trace("getCurrentPingData - subsession: " + aSubsession);
+
+    // Telemetry is disabled, don't gather any data.
+    if (!Services.telemetry.canRecordBase) {
+      return null;
+    }
+
+    const reason = aSubsession
+      ? REASON_GATHER_SUBSESSION_PAYLOAD
+      : REASON_GATHER_PAYLOAD;
+    const type = PING_TYPE_MAIN;
+    const payload = lazy.TelemetrySession.getPayload(reason);
+    const options = { addClientId: true, addEnvironment: true };
+    const ping = this.assemblePing(type, payload, options);
+
+    return ping;
+  },
+
+  async reset() {
+    this._clientID = null;
+    this._fnSyncPingShutdown = null;
+    this._detachObservers();
+
+    let sessionReset = lazy.TelemetrySession.testReset();
+
+    this._connectionsBarrier = new AsyncShutdown.Barrier(
+      "TelemetryController: Waiting for pending ping activity"
+    );
+    this._shutdownBarrier = new AsyncShutdown.Barrier(
+      "TelemetryController: Waiting for clients."
+    );
+
+    // We need to kick of the controller setup first for tests that check the
+    // cached client id.
+    let controllerSetup = this.setupTelemetry(true);
+
+    await sessionReset;
+    await lazy.TelemetrySend.reset();
+    await lazy.TelemetryStorage.reset();
+    await lazy.TelemetryEnvironment.testReset();
+
+    await controllerSetup;
+  },
+
+  /**
+   * Schedule sending the "new-profile" ping.
+   */
+  scheduleNewProfilePing() {
+    this._log.trace("scheduleNewProfilePing");
+
+    const sendDelay = Services.prefs.getIntPref(
+      TelemetryUtils.Preferences.NewProfilePingDelay,
+      NEWPROFILE_PING_DEFAULT_DELAY
+    );
+
+    try {
+      // This is asynchronous, but we aren't going to await on it now. Just
+      // kick it off.
+      lazy.ProvenanceData.submitProvenanceTelemetry();
+    } catch (ex) {
+      this._log.warn(
+        "scheduleNewProfilePing - submitProvenanceTelemetry failed",
+        ex
+      );
+    }
+
+    this._delayedNewPingTask = new DeferredTask(async () => {
+      try {
+        await this.sendNewProfilePing();
+      } finally {
+        this._delayedNewPingTask = null;
+      }
+    }, sendDelay);
+
+    this._delayedNewPingTask.arm();
+  },
+
+  /**
+   * Generate and send the new-profile ping
+   */
+  async sendNewProfilePing() {
+    this._log.trace(
+      "sendNewProfilePing - shutting down: " + this._shuttingDown
+    );
+
+    try {
+      await lazy.ProvenanceData.submitProvenanceTelemetry();
+    } catch (ex) {
+      this._log.warn(
+        "sendNewProfilePing - submitProvenanceTelemetry failed",
+        ex
+      );
+    }
+
+    const scalars = Services.telemetry.getSnapshotForScalars(
+      "new-profile",
+      /* clear */ true
+    );
+
+    // Generate the payload.
+    const payload = {
+      reason: this._shuttingDown ? "shutdown" : "startup",
+      processes: {
+        parent: {
+          scalars: scalars.parent,
+        },
+      },
+    };
+
+    // Generate and send the "new-profile" ping. This uses the
+    // pingsender if we're shutting down.
+    let options = {
+      addClientId: true,
+      addEnvironment: true,
+      usePingSender: this._shuttingDown,
+    };
+    // TODO: we need to be smarter about when to send the ping (and save the
+    // state to file). |requestIdleCallback| is currently only accessible
+    // through DOM. See bug 1361996.
+    await TelemetryController.submitExternalPing(
+      "new-profile",
+      payload,
+      options
+    ).then(
+      () => lazy.TelemetrySession.markNewProfilePingSent(),
+      e =>
+        this._log.error(
+          "sendNewProfilePing - failed to submit new-profile ping",
+          e
+        )
+    );
+  },
+
+  /**
+   * Register 'dynamic builtin' probes from the JSON definition files.
+   * This is needed to support adding new probes in developer builds
+   * without rebuilding the whole codebase.
+   *
+   * This is not meant to be used outside of local developer builds.
+   */
+  async registerJsProbes() {
+    // We don't support this outside of developer builds.
+    if (AppConstants.MOZILLA_OFFICIAL && !this._testMode) {
+      return;
+    }
+
+    this._log.trace("registerJsProbes - registering builtin JS probes");
+
+    await this.registerScalarProbes();
+    await this.registerEventProbes();
+  },
+
+  _loadProbeDefinitions(filename) {
+    let probeFile = Services.dirsvc.get("GreD", Ci.nsIFile);
+    probeFile.append(filename);
+    if (!probeFile.exists()) {
+      this._log.trace(
+        `loadProbeDefinitions - no builtin JS probe file ${filename}`
+      );
+      return null;
+    }
+
+    return IOUtils.readUTF8(probeFile.path);
+  },
+
+  async registerScalarProbes() {
+    this._log.trace(
+      "registerScalarProbes - registering scalar builtin JS probes"
+    );
+
+    // Load the scalar probes JSON file.
+    const scalarProbeFilename = "ScalarArtifactDefinitions.json";
+    let scalarJSProbes = {};
+    try {
+      let fileContent = await this._loadProbeDefinitions(scalarProbeFilename);
+      scalarJSProbes = JSON.parse(fileContent, (property, value) => {
+        // Fixup the "kind" property: it's a string, and we need the constant
+        // coming from nsITelemetry.
+        if (property !== "kind" || typeof value != "string") {
+          return value;
+        }
+
+        let newValue;
+        switch (value) {
+          case "nsITelemetry::SCALAR_TYPE_COUNT":
+            newValue = Services.telemetry.SCALAR_TYPE_COUNT;
+            break;
+          case "nsITelemetry::SCALAR_TYPE_BOOLEAN":
+            newValue = Services.telemetry.SCALAR_TYPE_BOOLEAN;
+            break;
+          case "nsITelemetry::SCALAR_TYPE_STRING":
+            newValue = Services.telemetry.SCALAR_TYPE_STRING;
+            break;
+        }
+        return newValue;
+      });
+    } catch (ex) {
+      this._log.error(
+        `registerScalarProbes - there was an error loading ${scalarProbeFilename}`,
+        ex
+      );
+    }
+
+    // Register the builtin probes.
+    for (let category in scalarJSProbes) {
+      // Expire the expired scalars
+      for (let name in scalarJSProbes[category]) {
+        let def = scalarJSProbes[category][name];
+        if (
+          !def ||
+          !def.expires ||
+          def.expires == "never" ||
+          def.expires == "default"
+        ) {
+          continue;
+        }
+        if (
+          Services.vc.compare(AppConstants.MOZ_APP_VERSION, def.expires) >= 0
+        ) {
+          def.expired = true;
+        }
+      }
+      Services.telemetry.registerBuiltinScalars(
+        category,
+        scalarJSProbes[category]
+      );
+    }
+  },
+
+  async registerEventProbes() {
+    this._log.trace(
+      "registerEventProbes - registering builtin JS Event probes"
+    );
+
+    // Load the event probes JSON file.
+    const eventProbeFilename = "EventArtifactDefinitions.json";
+    let eventJSProbes = {};
+    try {
+      let fileContent = await this._loadProbeDefinitions(eventProbeFilename);
+      eventJSProbes = JSON.parse(fileContent);
+    } catch (ex) {
+      this._log.error(
+        `registerEventProbes - there was an error loading ${eventProbeFilename}`,
+        ex
+      );
+    }
+
+    // Register the builtin probes.
+    for (let category in eventJSProbes) {
+      for (let name in eventJSProbes[category]) {
+        let def = eventJSProbes[category][name];
+        if (
+          !def ||
+          !def.expires ||
+          def.expires == "never" ||
+          def.expires == "default"
+        ) {
+          continue;
+        }
+        if (
+          Services.vc.compare(AppConstants.MOZ_APP_VERSION, def.expires) >= 0
+        ) {
+          def.expired = true;
+        }
+      }
+      Services.telemetry.registerBuiltinEvents(
+        category,
+        eventJSProbes[category]
+      );
+    }
+  },
+};