The Tor Browser: toolkit/components/telemetry/TelemetryPing.jsm@925c144e1f1f (annotated)

toolkit/components/telemetry/TelemetryPing.jsm@925c144e1f1f (annotated)

toolkit/components/telemetry/TelemetryPing.jsm

Fri, 16 Jan 2015 18:13:44 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Fri, 16 Jan 2015 18:13:44 +0100
branch: TOR_BUG_9701
changeset 14: 925c144e1f1f
permissions: -rw-r--r--

Integrate suggestion from review to improve consistency with existing code.

 /* -*- 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/. */
 "use strict";
 const Cc = Components.classes;
 const Ci = Components.interfaces;
 const Cr = Components.results;
 const Cu = Components.utils;
 Cu.import("resource://gre/modules/debug.js", this);
 Cu.import("resource://gre/modules/Services.jsm", this);
 Cu.import("resource://gre/modules/XPCOMUtils.jsm", this);
 #ifndef MOZ_WIDGET_GONK
 Cu.import("resource://gre/modules/LightweightThemeManager.jsm", this);
 #endif
 Cu.import("resource://gre/modules/ThirdPartyCookieProbe.jsm", this);
 Cu.import("resource://gre/modules/Promise.jsm", this);
 Cu.import("resource://gre/modules/Task.jsm", this);
 Cu.import("resource://gre/modules/AsyncShutdown.jsm", this);
 // When modifying the payload in incompatible ways, please bump this version number
 const PAYLOAD_VERSION = 1;
 // This is the HG changeset of the Histogram.json file, used to associate
 // submitted ping data with its histogram definition (bug 832007)
 #expand const HISTOGRAMS_FILE_VERSION = "__HISTOGRAMS_FILE_VERSION__";
 const PREF_BRANCH = "toolkit.telemetry.";
 const PREF_SERVER = PREF_BRANCH + "server";
 const PREF_ENABLED = PREF_BRANCH + "enabled";
 const PREF_PREVIOUS_BUILDID = PREF_BRANCH + "previousBuildID";
 // Do not gather data more than once a minute
 const TELEMETRY_INTERVAL = 60000;
 // Delay before intializing telemetry (ms)
 const TELEMETRY_DELAY = 60000;
 // Delay before initializing telemetry if we're testing (ms)
 const TELEMETRY_TEST_DELAY = 100;
 // Seconds of idle time before pinging.
 // On idle-daily a gather-telemetry notification is fired, during it probes can
 // start asynchronous tasks to gather data.  On the next idle the data is sent.
 const IDLE_TIMEOUT_SECONDS = 5 * 60;
 var gLastMemoryPoll = null;
 let gWasDebuggerAttached = false;
 function getLocale() {
   return Cc["@mozilla.org/chrome/chrome-registry;1"].
          getService(Ci.nsIXULChromeRegistry).
          getSelectedLocale('global');
 }
 XPCOMUtils.defineLazyServiceGetter(this, "Telemetry",
                                    "@mozilla.org/base/telemetry;1",
                                    "nsITelemetry");
 XPCOMUtils.defineLazyServiceGetter(this, "idleService",
                                    "@mozilla.org/widget/idleservice;1",
                                    "nsIIdleService");
 XPCOMUtils.defineLazyModuleGetter(this, "UpdateChannel",
                                   "resource://gre/modules/UpdateChannel.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "AddonManagerPrivate",
                                   "resource://gre/modules/AddonManager.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "TelemetryFile",
                                   "resource://gre/modules/TelemetryFile.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "UITelemetry",
                                   "resource://gre/modules/UITelemetry.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "TelemetryLog",
                                   "resource://gre/modules/TelemetryLog.jsm");
 function generateUUID() {
   let str = Cc["@mozilla.org/uuid-generator;1"].getService(Ci.nsIUUIDGenerator).generateUUID().toString();
   // strip {}
   return str.substring(1, str.length - 1);
 }
 /**
  * Read current process I/O counters.
  */
 let processInfo = {
   _initialized: false,
   _IO_COUNTERS: null,
   _kernel32: null,
   _GetProcessIoCounters: null,
   _GetCurrentProcess: null,
   getCounters: function() {
     let isWindows = ("@mozilla.org/windows-registry-key;1" in Components.classes);
     if (isWindows)
       return this.getCounters_Windows();
     return null;
   },
   getCounters_Windows: function() {
     if (!this._initialized){
       Cu.import("resource://gre/modules/ctypes.jsm");
       this._IO_COUNTERS = new ctypes.StructType("IO_COUNTERS", [
         {'readOps': ctypes.unsigned_long_long},
         {'writeOps': ctypes.unsigned_long_long},
         {'otherOps': ctypes.unsigned_long_long},
         {'readBytes': ctypes.unsigned_long_long},
         {'writeBytes': ctypes.unsigned_long_long},
         {'otherBytes': ctypes.unsigned_long_long} ]);
       try {
         this._kernel32 = ctypes.open("Kernel32.dll");
         this._GetProcessIoCounters = this._kernel32.declare("GetProcessIoCounters",
           ctypes.winapi_abi,
           ctypes.bool, // return
           ctypes.voidptr_t, // hProcess
           this._IO_COUNTERS.ptr); // lpIoCounters
         this._GetCurrentProcess = this._kernel32.declare("GetCurrentProcess",
           ctypes.winapi_abi,
           ctypes.voidptr_t); // return
         this._initialized = true;
       } catch (err) {
         return null;
       }
     }
     let io = new this._IO_COUNTERS();
     if(!this._GetProcessIoCounters(this._GetCurrentProcess(), io.address()))
       return null;
     return [parseInt(io.readBytes), parseInt(io.writeBytes)];
   }
 };
 this.EXPORTED_SYMBOLS = ["TelemetryPing"];
 this.TelemetryPing = Object.freeze({
   /**
    * Returns the current telemetry payload.
    * @returns Object
    */
   getPayload: function() {
     return Impl.getPayload();
   },
   /**
    * Save histograms to a file.
    * Used only for testing purposes.
    *
    * @param {nsIFile} aFile The file to load from.
    */
   testSaveHistograms: function(aFile) {
     return Impl.testSaveHistograms(aFile);
   },
   /**
    * Collect and store information about startup.
    */
   gatherStartup: function() {
     return Impl.gatherStartup();
   },
   /**
    * Inform the ping which AddOns are installed.
    *
    * @param aAddOns - The AddOns.
    */
   setAddOns: function(aAddOns) {
     return Impl.setAddOns(aAddOns);
   },
   /**
    * Send a ping to a test server. Used only for testing.
    *
    * @param aServer - The server.
    */
   testPing: function(aServer) {
     return Impl.testPing(aServer);
   },
   /**
    * Load histograms from a file.
    * Used only for testing purposes.
    *
    * @param aFile - File to load from.
    */
   testLoadHistograms: function(aFile) {
     return Impl.testLoadHistograms(aFile);
   },
   /**
    * Returns the path component of the current submission URL.
    * @returns String
    */
   submissionPath: function() {
     return Impl.submissionPath();
   },
   Constants: Object.freeze({
     PREF_ENABLED: PREF_ENABLED,
     PREF_SERVER: PREF_SERVER,
     PREF_PREVIOUS_BUILDID: PREF_PREVIOUS_BUILDID,
   }),
   /**
    * Used only for testing purposes.
    */
   reset: function() {
     this.uninstall();
     return this.setup();
   },
   /**
    * Used only for testing purposes.
    */
   setup: function() {
     return Impl.setup(true);
   },
   /**
    * Used only for testing purposes.
    */
   uninstall: function() {
     try {
       Impl.uninstall();
     } catch (ex) {
       // Ignore errors
     }
   },
   /**
    * Descriptive metadata
    *
    * @param  reason
    *         The reason for the telemetry ping, this will be included in the
    *         returned metadata,
    * @return The metadata as a JS object
    */
   getMetadata: function(reason) {
     return Impl.getMetadata(reason);
   },
   /**
    * Send a notification.
    */
   observe: function (aSubject, aTopic, aData) {
     return Impl.observe(aSubject, aTopic, aData);
   }
 });
 let Impl = {
   _histograms: {},
   _initialized: false,
   _prevValues: {},
   // Generate a unique id once per session so the server can cope with
   // duplicate submissions.
   _uuid: generateUUID(),
   // Regex that matches histograms we care about during startup.
   // Keep this in sync with gen-histogram-bucket-ranges.py.
   _startupHistogramRegex: /SQLITE|HTTP|SPDY|CACHE|DNS/,
   _slowSQLStartup: {},
   _prevSession: null,
   _hasWindowRestoredObserver: false,
   _hasXulWindowVisibleObserver: false,
   _startupIO : {},
   // 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,
   /**
    * Gets a series of simple measurements (counters). At the moment, this
    * only returns startup data from nsIAppStartup.getStartupInfo().
    *
    * @return simple measurements as a dictionary.
    */
   getSimpleMeasurements: function getSimpleMeasurements(forSavedSession) {
     let si = Services.startup.getStartupInfo();
     var ret = {
       // uptime in minutes
       uptime: Math.round((new Date() - si.process) / 60000)
     }
     // Look for app-specific timestamps
     var appTimestamps = {};
     try {
       let o = {};
       Cu.import("resource://gre/modules/TelemetryTimestamps.jsm", o);
       appTimestamps = o.TelemetryTimestamps.get();
     } catch (ex) {}
     try {
       ret.addonManager = AddonManagerPrivate.getSimpleMeasures();
     } catch (ex) {}
     try {
       ret.UITelemetry = UITelemetry.getSimpleMeasures();
     } catch (ex) {}
     if (si.process) {
       for each (let field in Object.keys(si)) {
         if (field == "process")
           continue;
         ret[field] = si[field] - si.process
       }
       for (let p in appTimestamps) {
         if (!(p in ret) && appTimestamps[p])
           ret[p] = appTimestamps[p] - si.process;
       }
     }
     ret.startupInterrupted = Number(Services.startup.interrupted);
     // Update debuggerAttached flag
     let debugService = Cc["@mozilla.org/xpcom/debug;1"].getService(Ci.nsIDebug2);
     let isDebuggerAttached = debugService.isDebuggerAttached;
     gWasDebuggerAttached = gWasDebuggerAttached || isDebuggerAttached;
     ret.debuggerAttached = Number(gWasDebuggerAttached);
     ret.js = Cu.getJSEngineTelemetryValue();
     let shutdownDuration = Telemetry.lastShutdownDuration;
     if (shutdownDuration)
       ret.shutdownDuration = shutdownDuration;
     let failedProfileLockCount = Telemetry.failedProfileLockCount;
     if (failedProfileLockCount)
       ret.failedProfileLockCount = failedProfileLockCount;
     let maximalNumberOfConcurrentThreads = Telemetry.maximalNumberOfConcurrentThreads;
     if (maximalNumberOfConcurrentThreads)
       ret.maximalNumberOfConcurrentThreads = maximalNumberOfConcurrentThreads;
     for (let ioCounter in this._startupIO)
       ret[ioCounter] = this._startupIO[ioCounter];
     let hasPingBeenSent = false;
     try {
       hasPingBeenSent = Telemetry.getHistogramById("TELEMETRY_SUCCESS").snapshot().sum > 0;
     } catch(e) {
     }
     if (!forSavedSession || hasPingBeenSent) {
       ret.savedPings = TelemetryFile.pingsLoaded;
     }
     ret.pingsOverdue = TelemetryFile.pingsOverdue;
     ret.pingsDiscarded = TelemetryFile.pingsDiscarded;
     return ret;
   },
   /**
    * When reflecting a histogram into JS, Telemetry hands us an object
    * with the following properties:
    *
    * - min, max, histogram_type, sum, sum_squares_{lo,hi}: simple integers;
    * - log_sum, log_sum_squares: doubles;
    * - counts: array of counts for histogram buckets;
    * - ranges: array of calculated bucket sizes.
    *
    * This format is not straightforward to read and potentially bulky
    * with lots of zeros in the counts array.  Packing histograms makes
    * raw histograms easier to read and compresses the data a little bit.
    *
    * Returns an object:
    * { range: [min, max], bucket_count: <number of buckets>,
    *   histogram_type: <histogram_type>, sum: <sum>,
    *   sum_squares_lo: <sum_squares_lo>,
    *   sum_squares_hi: <sum_squares_hi>,
    *   log_sum: <log_sum>, log_sum_squares: <log_sum_squares>,
    *   values: { bucket1: count1, bucket2: count2, ... } }
    */
   packHistogram: function packHistogram(hgram) {
     let r = hgram.ranges;;
     let c = hgram.counts;
     let retgram = {
       range: [r[1], r[r.length - 1]],
       bucket_count: r.length,
       histogram_type: hgram.histogram_type,
       values: {},
       sum: hgram.sum
     };
     if (hgram.histogram_type == Telemetry.HISTOGRAM_EXPONENTIAL) {
       retgram.log_sum = hgram.log_sum;
       retgram.log_sum_squares = hgram.log_sum_squares;
     } else {
       retgram.sum_squares_lo = hgram.sum_squares_lo;
       retgram.sum_squares_hi = hgram.sum_squares_hi;
     }
     let first = true;
     let last = 0;
     for (let i = 0; i < c.length; i++) {
       let value = c[i];
       if (!value)
         continue;
       // add a lower bound
       if (i && first) {
         retgram.values[r[i - 1]] = 0;
       }
       first = false;
       last = i + 1;
       retgram.values[r[i]] = value;
     }
     // add an upper bound
     if (last && last < c.length)
       retgram.values[r[last]] = 0;
     return retgram;
   },
   getHistograms: function getHistograms(hls) {
     let registered = Telemetry.registeredHistograms([]);
     let ret = {};
     for (let name of registered) {
       for (let n of [name, "STARTUP_" + name]) {
         if (n in hls) {
           ret[n] = this.packHistogram(hls[n]);
         }
       }
     }
     return ret;
   },
   getAddonHistograms: function getAddonHistograms() {
     let ahs = Telemetry.addonHistogramSnapshots;
     let ret = {};
     for (let addonName in ahs) {
       let addonHistograms = ahs[addonName];
       let packedHistograms = {};
       for (let name in addonHistograms) {
         packedHistograms[name] = this.packHistogram(addonHistograms[name]);
       }
       if (Object.keys(packedHistograms).length != 0)
         ret[addonName] = packedHistograms;
     }
     return ret;
   },
   getThreadHangStats: function getThreadHangStats(stats) {
     stats.forEach((thread) => {
       thread.activity = this.packHistogram(thread.activity);
       thread.hangs.forEach((hang) => {
         hang.histogram = this.packHistogram(hang.histogram);
       });
     });
     return stats;
   },
   /**
    * Descriptive metadata
    *
    * @param  reason
    *         The reason for the telemetry ping, this will be included in the
    *         returned metadata,
    * @return The metadata as a JS object
    */
   getMetadata: function getMetadata(reason) {
     let ai = Services.appinfo;
     let ret = {
       reason: reason,
       OS: ai.OS,
       appID: ai.ID,
       appVersion: ai.version,
       appName: ai.name,
       appBuildID: ai.appBuildID,
       appUpdateChannel: UpdateChannel.get(),
       platformBuildID: ai.platformBuildID,
       revision: HISTOGRAMS_FILE_VERSION,
       locale: getLocale()
     };
     // In order to share profile data, the appName used for Metro Firefox is "Firefox",
     // (the same as desktop Firefox). We set it to "MetroFirefox" here in order to
     // differentiate telemetry pings sent by desktop vs. metro Firefox.
     if(Services.metro && Services.metro.immersive) {
       ret.appName = "MetroFirefox";
     }
     if (this._previousBuildID) {
       ret.previousBuildID = this._previousBuildID;
     }
     // sysinfo fields are not always available, get what we can.
     let sysInfo = Cc["@mozilla.org/system-info;1"].getService(Ci.nsIPropertyBag2);
     let fields = ["cpucount", "memsize", "arch", "version", "kernel_version",
                   "device", "manufacturer", "hardware", "tablet",
                   "hasMMX", "hasSSE", "hasSSE2", "hasSSE3",
                   "hasSSSE3", "hasSSE4A", "hasSSE4_1", "hasSSE4_2",
                   "hasEDSP", "hasARMv6", "hasARMv7", "hasNEON", "isWow64",
                   "profileHDDModel", "profileHDDRevision", "binHDDModel",
                   "binHDDRevision", "winHDDModel", "winHDDRevision"];
     for each (let field in fields) {
       let value;
       try {
         value = sysInfo.getProperty(field);
       } catch (e) {
         continue;
       }
       if (field == "memsize") {
         // Send RAM size in megabytes. Rounding because sysinfo doesn't
         // always provide RAM in multiples of 1024.
         value = Math.round(value / 1024 / 1024);
       }
       ret[field] = value;
     }
     // gfxInfo fields are not always available, get what we can.
     let gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
     let gfxfields = ["adapterDescription", "adapterVendorID", "adapterDeviceID",
                      "adapterRAM", "adapterDriver", "adapterDriverVersion",
                      "adapterDriverDate", "adapterDescription2",
                      "adapterVendorID2", "adapterDeviceID2", "adapterRAM2",
                      "adapterDriver2", "adapterDriverVersion2",
                      "adapterDriverDate2", "isGPU2Active", "D2DEnabled",
                      "DWriteEnabled", "DWriteVersion"
                     ];
     if (gfxInfo) {
       for each (let field in gfxfields) {
         try {
           let value = gfxInfo[field];
           // bug 940806: We need to do a strict equality comparison here,
           // otherwise a type conversion will occur and boolean false values
           // will get filtered out
           if (value !== "") {
             ret[field] = value;
           }
         } catch (e) {
           continue
         }
       }
     }
 #ifndef MOZ_WIDGET_GONK
     let theme = LightweightThemeManager.currentTheme;
     if (theme)
       ret.persona = theme.id;
 #endif
     if (this._addons)
       ret.addons = this._addons;
     let flashVersion = this.getFlashVersion();
     if (flashVersion)
       ret.flashVersion = flashVersion;
     try {
       let scope = {};
       Cu.import("resource:///modules/experiments/Experiments.jsm", scope);
       let experiments = scope.Experiments.instance()
       let activeExperiment = experiments.getActiveExperimentID();
       if (activeExperiment) {
         ret.activeExperiment = activeExperiment;
 	ret.activeExperimentBranch = experiments.getActiveExperimentBranch();
       }
     } catch(e) {
       // If this is not Firefox, the import will fail.
     }
     return ret;
   },
   /**
    * Pull values from about:memory into corresponding histograms
    */
   gatherMemory: function gatherMemory() {
     let mgr;
     try {
       mgr = Cc["@mozilla.org/memory-reporter-manager;1"].
             getService(Ci.nsIMemoryReporterManager);
     } catch (e) {
       // OK to skip memory reporters in xpcshell
       return;
     }
     let histogram = Telemetry.getHistogramById("TELEMETRY_MEMORY_REPORTER_MS");
     let startTime = new Date();
     // Get memory measurements from distinguished amount attributes.  We used
     // to measure "explicit" too, but it could cause hangs, and the data was
     // always really noisy anyway.  See bug 859657.
     //
     // test_TelemetryPing.js relies on some of these histograms being
     // here.  If you remove any of the following histograms from here, you'll
     // have to modify test_TelemetryPing.js:
     //
     //   * MEMORY_JS_GC_HEAP, and
     //   * MEMORY_JS_COMPARTMENTS_SYSTEM.
     //
     // The distinguished amount attribute names don't match the telemetry id
     // names in some cases due to a combination of (a) historical reasons, and
     // (b) the fact that we can't change telemetry id names without breaking
     // data continuity.
     //
     let boundHandleMemoryReport = this.handleMemoryReport.bind(this);
     function h(id, units, amountName) {
       try {
         // If mgr[amountName] throws an exception, just move on -- some amounts
         // aren't available on all platforms.  But if the attribute simply
         // isn't present, that indicates the distinguished amounts have changed
         // and this file hasn't been updated appropriately.
         let amount = mgr[amountName];
         NS_ASSERT(amount !== undefined,
                   "telemetry accessed an unknown distinguished amount");
         boundHandleMemoryReport(id, units, amount);
       } catch (e) {
       };
     }
     let b = (id, n) => h(id, Ci.nsIMemoryReporter.UNITS_BYTES, n);
     let c = (id, n) => h(id, Ci.nsIMemoryReporter.UNITS_COUNT, n);
     let cc= (id, n) => h(id, Ci.nsIMemoryReporter.UNITS_COUNT_CUMULATIVE, n);
     let p = (id, n) => h(id, Ci.nsIMemoryReporter.UNITS_PERCENTAGE, n);
     b("MEMORY_VSIZE", "vsize");
     b("MEMORY_VSIZE_MAX_CONTIGUOUS", "vsizeMaxContiguous");
     b("MEMORY_RESIDENT", "residentFast");
     b("MEMORY_HEAP_ALLOCATED", "heapAllocated");
     p("MEMORY_HEAP_COMMITTED_UNUSED_RATIO", "heapOverheadRatio");
     b("MEMORY_JS_GC_HEAP", "JSMainRuntimeGCHeap");
     b("MEMORY_JS_MAIN_RUNTIME_TEMPORARY_PEAK", "JSMainRuntimeTemporaryPeak");
     c("MEMORY_JS_COMPARTMENTS_SYSTEM", "JSMainRuntimeCompartmentsSystem");
     c("MEMORY_JS_COMPARTMENTS_USER", "JSMainRuntimeCompartmentsUser");
     b("MEMORY_IMAGES_CONTENT_USED_UNCOMPRESSED", "imagesContentUsedUncompressed");
     b("MEMORY_STORAGE_SQLITE", "storageSQLite");
     cc("MEMORY_EVENTS_VIRTUAL", "lowMemoryEventsVirtual");
     cc("MEMORY_EVENTS_PHYSICAL", "lowMemoryEventsPhysical");
     c("GHOST_WINDOWS", "ghostWindows");
     cc("PAGE_FAULTS_HARD", "pageFaultsHard");
     histogram.add(new Date() - startTime);
   },
   handleMemoryReport: function(id, units, amount) {
     let val;
     if (units == Ci.nsIMemoryReporter.UNITS_BYTES) {
       val = Math.floor(amount / 1024);
     }
     else if (units == Ci.nsIMemoryReporter.UNITS_PERCENTAGE) {
       // UNITS_PERCENTAGE amounts are 100x greater than their raw value.
       val = Math.floor(amount / 100);
     }
     else if (units == Ci.nsIMemoryReporter.UNITS_COUNT) {
       val = amount;
     }
     else if (units == Ci.nsIMemoryReporter.UNITS_COUNT_CUMULATIVE) {
       // If the reporter gives us a cumulative count, we'll report the
       // difference in its value between now and our previous ping.
       if (!(id in this._prevValues)) {
         // If this is the first time we're reading this reporter, store its
         // current value but don't report it in the telemetry ping, so we
         // ignore the effect startup had on the reporter.
         this._prevValues[id] = amount;
         return;
       }
       val = amount - this._prevValues[id];
       this._prevValues[id] = amount;
     }
     else {
       NS_ASSERT(false, "Can't handle memory reporter with units " + units);
       return;
     }
     let h = this._histograms[id];
     if (!h) {
       h = Telemetry.getHistogramById(id);
       this._histograms[id] = h;
     }
     h.add(val);
   },
   /**
    * Return true if we're interested in having a STARTUP_* histogram for
    * the given histogram name.
    */
   isInterestingStartupHistogram: function isInterestingStartupHistogram(name) {
     return this._startupHistogramRegex.test(name);
   },
   /**
    * Make a copy of interesting histograms at startup.
    */
   gatherStartupHistograms: function gatherStartupHistograms() {
     let info = Telemetry.registeredHistograms([]);
     let snapshots = Telemetry.histogramSnapshots;
     for (let name of info) {
       // Only duplicate histograms with actual data.
       if (this.isInterestingStartupHistogram(name) && name in snapshots) {
         Telemetry.histogramFrom("STARTUP_" + name, name);
       }
     }
   },
   /**
    * Get the current session's payload using the provided
    * simpleMeasurements and info, which are typically obtained by a call
    * to |this.getSimpleMeasurements| and |this.getMetadata|,
    * respectively.
    */
   assemblePayloadWithMeasurements: function assemblePayloadWithMeasurements(simpleMeasurements, info) {
     let payloadObj = {
       ver: PAYLOAD_VERSION,
       simpleMeasurements: simpleMeasurements,
       histograms: this.getHistograms(Telemetry.histogramSnapshots),
       slowSQL: Telemetry.slowSQL,
       fileIOReports: Telemetry.fileIOReports,
       chromeHangs: Telemetry.chromeHangs,
       threadHangStats: this.getThreadHangStats(Telemetry.threadHangStats),
       lateWrites: Telemetry.lateWrites,
       addonHistograms: this.getAddonHistograms(),
       addonDetails: AddonManagerPrivate.getTelemetryDetails(),
       UIMeasurements: UITelemetry.getUIMeasurements(),
       log: TelemetryLog.entries(),
       info: info
     };
     if (Object.keys(this._slowSQLStartup).length != 0 &&
         (Object.keys(this._slowSQLStartup.mainThread).length ||
          Object.keys(this._slowSQLStartup.otherThreads).length)) {
       payloadObj.slowSQLStartup = this._slowSQLStartup;
     }
     return payloadObj;
   },
   getSessionPayload: function getSessionPayload(reason) {
     let measurements = this.getSimpleMeasurements(reason == "saved-session");
     let info = this.getMetadata(reason);
     return this.assemblePayloadWithMeasurements(measurements, info);
   },
   assemblePing: function assemblePing(payloadObj, reason) {
     let slug = this._uuid;
     return { slug: slug, reason: reason, payload: payloadObj };
   },
   getSessionPayloadAndSlug: function getSessionPayloadAndSlug(reason) {
     return this.assemblePing(this.getSessionPayload(reason), reason);
   },
   popPayloads: function popPayloads(reason) {
     function payloadIter() {
       if (reason != "overdue-flush") {
         yield this.getSessionPayloadAndSlug(reason);
       }
       let iterator = TelemetryFile.popPendingPings(reason);
       for (let data of iterator) {
         yield data;
       }
     }
     let payloadIterWithThis = payloadIter.bind(this);
     return { __iterator__: payloadIterWithThis };
   },
   /**
    * Send data to the server. Record success/send-time in histograms
    */
   send: function send(reason, server) {
     // populate histograms one last time
     this.gatherMemory();
     return this.sendPingsFromIterator(server, reason,
                                Iterator(this.popPayloads(reason)));
   },
   sendPingsFromIterator: function sendPingsFromIterator(server, reason, i) {
     let p = [data for (data in i)].map((data) =>
       this.doPing(server, data).then(null, () => TelemetryFile.savePing(data, true)));
     return Promise.all(p);
   },
   finishPingRequest: function finishPingRequest(success, startTime, ping) {
     let hping = Telemetry.getHistogramById("TELEMETRY_PING");
     let hsuccess = Telemetry.getHistogramById("TELEMETRY_SUCCESS");
     hsuccess.add(success);
     hping.add(new Date() - startTime);
     if (success) {
       return TelemetryFile.cleanupPingFile(ping);
     } else {
       return Promise.resolve();
     }
   },
   submissionPath: function submissionPath(ping) {
     let slug;
     if (!ping) {
       slug = this._uuid;
     } else {
       let info = ping.payload.info;
       let pathComponents = [ping.slug, info.reason, info.appName,
                             info.appVersion, info.appUpdateChannel,
                             info.appBuildID];
       slug = pathComponents.join("/");
     }
     return "/submit/telemetry/" + slug;
   },
   doPing: function doPing(server, ping) {
     let deferred = Promise.defer();
     let url = server + this.submissionPath(ping);
     let request = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"]
                   .createInstance(Ci.nsIXMLHttpRequest);
     request.mozBackgroundRequest = true;
     request.open("POST", url, true);
     request.overrideMimeType("text/plain");
     request.setRequestHeader("Content-Type", "application/json; charset=UTF-8");
     let startTime = new Date();
     function handler(success) {
       return function(event) {
         this.finishPingRequest(success, startTime, ping).then(() => {
           if (success) {
             deferred.resolve();
           } else {
             deferred.reject(event);
           }
         });
       };
     }
     request.addEventListener("error", handler(false).bind(this), false);
     request.addEventListener("load", handler(true).bind(this), false);
     request.setRequestHeader("Content-Encoding", "gzip");
     let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"]
                     .createInstance(Ci.nsIScriptableUnicodeConverter);
     converter.charset = "UTF-8";
     let utf8Payload = converter.ConvertFromUnicode(JSON.stringify(ping.payload));
     utf8Payload += converter.Finish();
     let payloadStream = Cc["@mozilla.org/io/string-input-stream;1"]
                         .createInstance(Ci.nsIStringInputStream);
     payloadStream.data = this.gzipCompressString(utf8Payload);
     request.send(payloadStream);
     return deferred.promise;
   },
   gzipCompressString: function gzipCompressString(string) {
     let observer = {
       buffer: "",
       onStreamComplete: function(loader, context, status, length, result) {
         this.buffer = String.fromCharCode.apply(this, result);
       }
     };
     let scs = Cc["@mozilla.org/streamConverters;1"]
               .getService(Ci.nsIStreamConverterService);
     let listener = Cc["@mozilla.org/network/stream-loader;1"]
                   .createInstance(Ci.nsIStreamLoader);
     listener.init(observer);
     let converter = scs.asyncConvertData("uncompressed", "gzip",
                                          listener, null);
     let stringStream = Cc["@mozilla.org/io/string-input-stream;1"]
                        .createInstance(Ci.nsIStringInputStream);
     stringStream.data = string;
     converter.onStartRequest(null, null);
     converter.onDataAvailable(null, null, stringStream, 0, string.length);
     converter.onStopRequest(null, null, null);
     return observer.buffer;
   },
   attachObservers: function attachObservers() {
     if (!this._initialized)
       return;
     Services.obs.addObserver(this, "cycle-collector-begin", false);
     Services.obs.addObserver(this, "idle-daily", false);
   },
   detachObservers: function detachObservers() {
     if (!this._initialized)
       return;
     Services.obs.removeObserver(this, "idle-daily");
     Services.obs.removeObserver(this, "cycle-collector-begin");
     if (this._isIdleObserver) {
       idleService.removeIdleObserver(this, IDLE_TIMEOUT_SECONDS);
       this._isIdleObserver = false;
     }
   },
   /**
    * Initializes telemetry within a timer. If there is no PREF_SERVER set, don't turn on telemetry.
    */
   setup: function setup(aTesting) {
     // Initialize some probes that are kept in their own modules
     this._thirdPartyCookies = new ThirdPartyCookieProbe();
     this._thirdPartyCookies.init();
     // Record old value and update build ID preference if this is the first
     // run with a new build ID.
     let previousBuildID = undefined;
     try {
       previousBuildID = Services.prefs.getCharPref(PREF_PREVIOUS_BUILDID);
     } catch (e) {
       // Preference was not set.
     }
     let thisBuildID = Services.appinfo.appBuildID;
     // If there is no previousBuildID preference, this._previousBuildID remains
     // undefined so no value is sent in the telemetry metadata.
     if (previousBuildID != thisBuildID) {
       this._previousBuildID = previousBuildID;
       Services.prefs.setCharPref(PREF_PREVIOUS_BUILDID, thisBuildID);
     }
 #ifdef MOZILLA_OFFICIAL
     if (!Telemetry.canSend) {
       // We can't send data; no point in initializing observers etc.
       // Only do this for official builds so that e.g. developer builds
       // still enable Telemetry based on prefs.
       Telemetry.canRecord = false;
       return;
     }
 #endif
     let enabled = false;
     try {
       enabled = Services.prefs.getBoolPref(PREF_ENABLED);
       this._server = Services.prefs.getCharPref(PREF_SERVER);
     } catch (e) {
       // Prerequesite prefs aren't set
     }
     if (!enabled) {
       // Turn off local telemetry if telemetry is disabled.
       // This may change once about:telemetry is added.
       Telemetry.canRecord = false;
       return;
     }
     AsyncShutdown.sendTelemetry.addBlocker(
       "Telemetry: shutting down",
       function condition(){
         this.uninstall();
         if (Telemetry.canSend) {
           return this.savePendingPings();
         }
       }.bind(this));
     Services.obs.addObserver(this, "sessionstore-windows-restored", false);
     Services.obs.addObserver(this, "quit-application-granted", false);
 #ifdef MOZ_WIDGET_ANDROID
     Services.obs.addObserver(this, "application-background", false);
 #endif
     Services.obs.addObserver(this, "xul-window-visible", false);
     this._hasWindowRestoredObserver = true;
     this._hasXulWindowVisibleObserver = true;
     // 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._timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
     let deferred = Promise.defer();
     function timerCallback() {
       Task.spawn(function*(){
         this._initialized = true;
         yield TelemetryFile.loadSavedPings();
         // If we have any TelemetryPings lying around, we'll be aggressive
         // and try to send them all off ASAP.
         if (TelemetryFile.pingsOverdue > 0) {
           // It doesn't really matter what we pass to this.send as a reason,
           // since it's never sent to the server. All that this.send does with
           // the reason is check to make sure it's not a test-ping.
           yield this.send("overdue-flush", this._server);
         }
         this.attachObservers();
         this.gatherMemory();
         Telemetry.asyncFetchTelemetryData(function () {});
         delete this._timer;
         deferred.resolve();
       }.bind(this));
     }
     this._timer.initWithCallback(timerCallback.bind(this),
                                  aTesting ? TELEMETRY_TEST_DELAY : TELEMETRY_DELAY,
                                  Ci.nsITimer.TYPE_ONE_SHOT);
     return deferred.promise;
   },
   testLoadHistograms: function testLoadHistograms(file) {
     return TelemetryFile.testLoadHistograms(file);
   },
   getFlashVersion: function getFlashVersion() {
     let host = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
     let tags = host.getPluginTags();
     for (let i = 0; i < tags.length; i++) {
       if (tags[i].name == "Shockwave Flash")
         return tags[i].version;
     }
     return null;
   },
   savePendingPings: function savePendingPings() {
     let sessionPing = this.getSessionPayloadAndSlug("saved-session");
     return TelemetryFile.savePendingPings(sessionPing);
   },
   testSaveHistograms: function testSaveHistograms(file) {
     return TelemetryFile.savePingToFile(this.getSessionPayloadAndSlug("saved-session"),
       file.path, true);
   },
   /**
    * Remove observers to avoid leaks
    */
   uninstall: function uninstall() {
     this.detachObservers();
     if (this._hasWindowRestoredObserver) {
       Services.obs.removeObserver(this, "sessionstore-windows-restored");
       this._hasWindowRestoredObserver = false;
     }
     if (this._hasXulWindowVisibleObserver) {
       Services.obs.removeObserver(this, "xul-window-visible");
       this._hasXulWindowVisibleObserver = false;
     }
     Services.obs.removeObserver(this, "quit-application-granted");
 #ifdef MOZ_WIDGET_ANDROID
     Services.obs.removeObserver(this, "application-background", false);
 #endif
   },
   getPayload: function getPayload() {
     // This function returns the current Telemetry payload to the caller.
     // We only gather startup info once.
     if (Object.keys(this._slowSQLStartup).length == 0) {
       this.gatherStartupHistograms();
       this._slowSQLStartup = Telemetry.slowSQL;
     }
     this.gatherMemory();
     return this.getSessionPayload("gather-payload");
   },
   gatherStartup: function gatherStartup() {
     let counters = processInfo.getCounters();
     if (counters) {
       [this._startupIO.startupSessionRestoreReadBytes,
         this._startupIO.startupSessionRestoreWriteBytes] = counters;
     }
     this.gatherStartupHistograms();
     this._slowSQLStartup = Telemetry.slowSQL;
   },
   setAddOns: function setAddOns(aAddOns) {
     this._addons = aAddOns;
   },
   sendIdlePing: function sendIdlePing(aTest, aServer) {
     if (this._isIdleObserver) {
       idleService.removeIdleObserver(this, IDLE_TIMEOUT_SECONDS);
       this._isIdleObserver = false;
     }
     if (aTest) {
       return this.send("test-ping", aServer);
     } else if (Telemetry.canSend) {
       return this.send("idle-daily", aServer);
     }
   },
   testPing: function testPing(server) {
     return this.sendIdlePing(true, server);
   },
   /**
    * This observer drives telemetry.
    */
   observe: function (aSubject, aTopic, aData) {
     switch (aTopic) {
     case "profile-after-change":
       return this.setup();
     case "cycle-collector-begin":
       let now = new Date();
       if (!gLastMemoryPoll
           || (TELEMETRY_INTERVAL <= now - gLastMemoryPoll)) {
         gLastMemoryPoll = now;
         this.gatherMemory();
       }
       break;
     case "xul-window-visible":
       Services.obs.removeObserver(this, "xul-window-visible");
       this._hasXulWindowVisibleObserver = false;
       var counters = processInfo.getCounters();
       if (counters) {
         [this._startupIO.startupWindowVisibleReadBytes,
           this._startupIO.startupWindowVisibleWriteBytes] = counters;
       }
       break;
     case "sessionstore-windows-restored":
       Services.obs.removeObserver(this, "sessionstore-windows-restored");
       this._hasWindowRestoredObserver = false;
       // Check whether debugger was attached during startup
       let debugService = Cc["@mozilla.org/xpcom/debug;1"].getService(Ci.nsIDebug2);
       gWasDebuggerAttached = debugService.isDebuggerAttached;
       this.gatherStartup();
       break;
     case "idle-daily":
       // Enqueue to main-thread, otherwise components may be inited by the
       // idle-daily category and miss the gather-telemetry notification.
       Services.tm.mainThread.dispatch((function() {
         // Notify that data should be gathered now, since ping will happen soon.
         Services.obs.notifyObservers(null, "gather-telemetry", null);
         // The ping happens at the first idle of length IDLE_TIMEOUT_SECONDS.
         idleService.addIdleObserver(this, IDLE_TIMEOUT_SECONDS);
         this._isIdleObserver = true;
       }).bind(this), Ci.nsIThread.DISPATCH_NORMAL);
       break;
     case "idle":
       this.sendIdlePing(false, this._server);
       break;
 #ifdef MOZ_WIDGET_ANDROID
     // On Android, we can get killed without warning once we are in the background,
     // but we may also submit data and/or come back into the foreground without getting
     // killed. To deal with this, we save the current session data to file when we are
     // put into the background. This handles the following post-backgrounding scenarios:
     // 1) We are killed immediately. In this case the current session data (which we
     //    save to a file) will be loaded and submitted on a future run.
     // 2) We submit the data while in the background, and then are killed. In this case
     //    the file that we saved will be deleted by the usual process in
     //    finishPingRequest after it is submitted.
     // 3) We submit the data, and then come back into the foreground. Same as case (2).
     // 4) We do not submit the data, but come back into the foreground. In this case
     //    we have the option of either deleting the file that we saved (since we will either
     //    send the live data while in the foreground, or create the file again on the next
     //    backgrounding), or not (in which case we will delete it on submit, or overwrite
     //    it on the next backgrounding). Not deleting it is faster, so that's what we do.
     case "application-background":
       if (Telemetry.canSend) {
         let ping = this.getSessionPayloadAndSlug("saved-session");
         TelemetryFile.savePing(ping, true);
       }
       break;
 #endif
     }
   },
 };

The Tor Browser / annotate

toolkit/components/telemetry/TelemetryPing.jsm@925c144e1f1f (annotated)

toolkit/components/telemetry/TelemetryPing.jsm