Bug 1950417 - Migrate memory histograms to Glean, making them also available for Firefox Android, r=chutten.

Differential Revision: https://phabricator.services.mozilla.com/D242035

js/xpconnect/loader/ScriptPreloader.cpp

@@ -24,6 +24,7 @@
 #include "mozilla/StaticPrefs_javascript.h"
 #include "mozilla/TaskController.h"
 #include "mozilla/glean/JsXpconnectMetrics.h"
+#include "mozilla/glean/XpcomMetrics.h"
 #include "mozilla/Telemetry.h"
 #include "mozilla/Try.h"
 #include "mozilla/Unused.h"
@@ -385,8 +386,7 @@ void ScriptPreloader::FinishContentStartup() {
   // privileged processes record this value at a different time, leading to
   // a higher value which skews the telemetry.
   if (sProcessType != ProcessType::PrivilegedAbout) {
-    mozilla::Telemetry::Accumulate(
+    mozilla::glean::memory::unique_content_startup.Accumulate(
-        mozilla::Telemetry::MEMORY_UNIQUE_CONTENT_STARTUP,
         nsMemoryReporterManager::ResidentUnique() / 1024);
   }
 #endif

toolkit/components/telemetry/Histograms.json

@@ -1560,17 +1560,6 @@
     "n_buckets": 10,
     "description": "Time(ms) to purge dirty heap pages."
   },
-  "LOW_MEMORY_EVENTS_VIRTUAL": {
-    "record_in_processes": ["main"],
-    "products": ["firefox", "fennec"],
-    "alert_emails": ["memshrink-telemetry-alerts@mozilla.com"],
-    "expires_in_version": "never",
-    "kind": "exponential",
-    "high": 1024,
-    "n_buckets": 21,
-    "description": "Number of low-virtual-memory events fired since last ping",
-    "bug_numbers": [711490, 1451005]
-  },
   "LOW_MEMORY_EVENTS_PHYSICAL": {
     "record_in_processes": ["main"],
     "products": ["firefox", "fennec"],
@@ -1582,17 +1571,6 @@
     "description": "Number of low-physical-memory events fired since last ping",
     "bug_numbers": [711490, 1451005]
   },
-  "LOW_MEMORY_EVENTS_COMMIT_SPACE": {
-    "record_in_processes": ["main"],
-    "products": ["firefox", "fennec"],
-    "alert_emails": ["memshrink-telemetry-alerts@mozilla.com"],
-    "expires_in_version": "never",
-    "kind": "exponential",
-    "high": 1024,
-    "n_buckets": 21,
-    "description": "Number of low-commit-space events fired since last ping",
-    "bug_numbers": [1451005]
-  },
   "PAGE_FAULTS_HARD": {
     "record_in_processes": ["main", "content"],
     "products": ["firefox", "fennec"],

xpcom/base/MemoryTelemetry.cpp

@@ -16,6 +16,7 @@
 #include "mozilla/Services.h"
 #include "mozilla/ScopeExit.h"
 #include "mozilla/SimpleEnumerator.h"
+#include "mozilla/glean/XpcomMetrics.h"
 #include "mozilla/Telemetry.h"
 #include "mozilla/TimeStamp.h"
 #include "mozilla/dom/ContentParent.h"
@@ -61,12 +62,10 @@ namespace {
 
 enum class PrevValue : uint32_t {
 #ifdef XP_WIN
-  LOW_MEMORY_EVENTS_VIRTUAL,
+  low_memory_events_physical,
-  LOW_MEMORY_EVENTS_COMMIT_SPACE,
-  LOW_MEMORY_EVENTS_PHYSICAL,
 #endif
 #if defined(XP_LINUX) && !defined(ANDROID)
-  PAGE_FAULTS_HARD,
+  page_faults_hard,
 #endif
   SIZE_,
 };
@@ -77,26 +76,6 @@ constexpr uint32_t kUninitialized = ~0;
 
 static uint32_t gPrevValues[uint32_t(PrevValue::SIZE_)];
 
-static uint32_t PrevValueIndex(Telemetry::HistogramID aId) {
-  switch (aId) {
-#ifdef XP_WIN
-    case Telemetry::LOW_MEMORY_EVENTS_VIRTUAL:
-      return uint32_t(PrevValue::LOW_MEMORY_EVENTS_VIRTUAL);
-    case Telemetry::LOW_MEMORY_EVENTS_COMMIT_SPACE:
-      return uint32_t(PrevValue::LOW_MEMORY_EVENTS_COMMIT_SPACE);
-    case Telemetry::LOW_MEMORY_EVENTS_PHYSICAL:
-      return uint32_t(PrevValue::LOW_MEMORY_EVENTS_PHYSICAL);
-#endif
-#if defined(XP_LINUX) && !defined(ANDROID)
-    case Telemetry::PAGE_FAULTS_HARD:
-      return uint32_t(PrevValue::PAGE_FAULTS_HARD);
-#endif
-    default:
-      MOZ_ASSERT_UNREACHABLE("Unexpected histogram ID");
-      return 0;
-  }
-}
-
 /*
  * Because even in "idle" processes there may be some background events,
  * ideally there shouldn't, we use a sliding window to determine if the process
@@ -258,57 +237,6 @@ nsresult MemoryTelemetry::Shutdown() {
   return NS_OK;
 }
 
-static inline void HandleMemoryReport(Telemetry::HistogramID aId,
-                                      int32_t aUnits, uint64_t aAmount,
-                                      const nsCString& aKey = VoidCString()) {
-  uint32_t val;
-  switch (aUnits) {
-    case nsIMemoryReporter::UNITS_BYTES:
-      val = uint32_t(aAmount / 1024);
-      break;
-
-    case nsIMemoryReporter::UNITS_PERCENTAGE:
-      // UNITS_PERCENTAGE amounts are 100x greater than their raw value.
-      val = uint32_t(aAmount / 100);
-      break;
-
-    case nsIMemoryReporter::UNITS_COUNT:
-      val = uint32_t(aAmount);
-      break;
-
-    case 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.
-
-      uint32_t idx = PrevValueIndex(aId);
-      uint32_t prev = gPrevValues[idx];
-      gPrevValues[idx] = aAmount;
-
-      if (prev == kUninitialized) {
-        // 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.
-        return;
-      }
-      val = aAmount - prev;
-      break;
-    }
-
-    default:
-      MOZ_ASSERT_UNREACHABLE("Unexpected aUnits value");
-      return;
-  }
-
-  // Note: The reference equality check here should allow the compiler to
-  // optimize this case out at compile time when we weren't given a key,
-  // while IsEmpty() or IsVoid() most likely will not.
-  if (&aKey == &VoidCString()) {
-    Telemetry::Accumulate(aId, val);
-  } else {
-    Telemetry::Accumulate(aId, aKey, val);
-  }
-}
-
 nsresult MemoryTelemetry::GatherReports(
     const std::function<void()>& aCompletionCallback) {
   auto cleanup = MakeScopeExit([&]() {
@@ -324,19 +252,36 @@ nsresult MemoryTelemetry::GatherReports(
   MOZ_DIAGNOSTIC_ASSERT(mgr);
   NS_ENSURE_TRUE(mgr, NS_ERROR_FAILURE);
 
-#define RECORD(id, metric, units)                                       \
+#define RECORD_OUTER(metric, inner)                                   \
-  do {                                                                  \
+  do {                                                                \
-    int64_t amt;                                                        \
+    int64_t amt;                                                      \
-    nsresult rv = mgr->Get##metric(&amt);                               \
+    nsresult rv = mgr->Get##metric(&amt);                             \
-    if (NS_SUCCEEDED(rv)) {                                             \
+    if (NS_SUCCEEDED(rv)) {                                           \
-      HandleMemoryReport(Telemetry::id, nsIMemoryReporter::units, amt); \
+      inner                                                           \
-    } else if (rv != NS_ERROR_NOT_AVAILABLE) {                          \
+    } else if (rv != NS_ERROR_NOT_AVAILABLE) {                        \
-      NS_WARNING("Failed to retrieve memory telemetry for " #metric);   \
+      NS_WARNING("Failed to retrieve memory telemetry for " #metric); \
-    }                                                                   \
+    }                                                                 \
   } while (0)
+#define RECORD_COUNT(id, metric) \
+  RECORD_OUTER(metric, glean::memory::id.AccumulateSingleSample(amt);)
+#define RECORD_BYTES(id, metric) \
+  RECORD_OUTER(metric, glean::memory::id.Accumulate(amt / 1024);)
+#define RECORD_PERCENTAGE(id, metric) \
+  RECORD_OUTER(metric, glean::memory::id.AccumulateSingleSample(amt / 100);)
+#define RECORD_COUNT_CUMULATIVE(id, metric)                               \
+  RECORD_OUTER(                                                           \
+      metric, uint32_t prev = gPrevValues[uint32_t(PrevValue::id)];       \
+      gPrevValues[uint32_t(PrevValue::id)] = amt;                         \
+                                                                          \
+      /* 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. */                \
+      if (prev != kUninitialized) {                                       \
+        glean::memory::id.AccumulateSingleSample(amt - prev);             \
+      })
 
   // GHOST_WINDOWS is opt-out as of Firefox 55
-  RECORD(GHOST_WINDOWS, GhostWindows, UNITS_COUNT);
+  RECORD_COUNT(ghost_windows, GhostWindows);
 
   // If we're running in the parent process, collect data from all processes for
   // the MEMORY_TOTAL histogram.
@@ -367,32 +312,26 @@ nsresult MemoryTelemetry::GatherReports(
 
   // Collect cheap or main-thread only metrics synchronously, on the main
   // thread.
-  RECORD(MEMORY_JS_GC_HEAP, JSMainRuntimeGCHeap, UNITS_BYTES);
+  RECORD_BYTES(js_gc_heap, JSMainRuntimeGCHeap);
-  RECORD(MEMORY_JS_COMPARTMENTS_SYSTEM, JSMainRuntimeCompartmentsSystem,
+  RECORD_COUNT(js_compartments_system, JSMainRuntimeCompartmentsSystem);
-         UNITS_COUNT);
+  RECORD_COUNT(js_compartments_user, JSMainRuntimeCompartmentsUser);
-  RECORD(MEMORY_JS_COMPARTMENTS_USER, JSMainRuntimeCompartmentsUser,
+  RECORD_COUNT(js_realms_system, JSMainRuntimeRealmsSystem);
-         UNITS_COUNT);
+  RECORD_COUNT(js_realms_user, JSMainRuntimeRealmsUser);
-  RECORD(MEMORY_JS_REALMS_SYSTEM, JSMainRuntimeRealmsSystem, UNITS_COUNT);
+  RECORD_BYTES(images_content_used_uncompressed, ImagesContentUsedUncompressed);
-  RECORD(MEMORY_JS_REALMS_USER, JSMainRuntimeRealmsUser, UNITS_COUNT);
+  RECORD_BYTES(storage_sqlite, StorageSQLite);
-  RECORD(MEMORY_IMAGES_CONTENT_USED_UNCOMPRESSED, ImagesContentUsedUncompressed,
-         UNITS_BYTES);
-  RECORD(MEMORY_STORAGE_SQLITE, StorageSQLite, UNITS_BYTES);
 #ifdef XP_WIN
-  RECORD(LOW_MEMORY_EVENTS_PHYSICAL, LowMemoryEventsPhysical,
+  RECORD_COUNT_CUMULATIVE(low_memory_events_physical, LowMemoryEventsPhysical);
-         UNITS_COUNT_CUMULATIVE);
 #endif
 #if defined(XP_LINUX) && !defined(ANDROID)
-  RECORD(PAGE_FAULTS_HARD, PageFaultsHard, UNITS_COUNT_CUMULATIVE);
+  RECORD_COUNT_CUMULATIVE(page_faults_hard, PageFaultsHard);
 #endif
 
 #ifdef HAVE_JEMALLOC_STATS
   jemalloc_stats_t stats;
   jemalloc_stats(&stats);
-  HandleMemoryReport(Telemetry::MEMORY_HEAP_ALLOCATED,
+  glean::memory::heap_allocated.Accumulate(mgr->HeapAllocated(stats) / 1024);
-                     nsIMemoryReporter::UNITS_BYTES, mgr->HeapAllocated(stats));
+  glean::memory::heap_overhead_fraction.AccumulateSingleSample(
-  HandleMemoryReport(Telemetry::MEMORY_HEAP_OVERHEAD_FRACTION,
+      mgr->HeapOverheadFraction(stats) / 100);
-                     nsIMemoryReporter::UNITS_PERCENTAGE,
-                     mgr->HeapOverheadFraction(stats));
 #endif
 
 #ifdef MOZ_PHC
@@ -408,17 +347,17 @@ nsresult MemoryTelemetry::GatherReports(
   // asynchronously, on a background thread.
   RefPtr<Runnable> runnable = NS_NewRunnableFunction(
       "MemoryTelemetry::GatherReports", [mgr, completionRunnable]() mutable {
-        Telemetry::AutoTimer<Telemetry::MEMORY_COLLECTION_TIME> autoTimer;
+        auto timer = glean::memory::collection_time.Measure();
-        RECORD(MEMORY_VSIZE, Vsize, UNITS_BYTES);
+        RECORD_BYTES(vsize, Vsize);
 #if !defined(HAVE_64BIT_BUILD) || !defined(XP_WIN)
-        RECORD(MEMORY_VSIZE_MAX_CONTIGUOUS, VsizeMaxContiguous, UNITS_BYTES);
+        RECORD_BYTES(vsize_max_contiguous, VsizeMaxContiguous);
 #endif
-        RECORD(MEMORY_RESIDENT_FAST, ResidentFast, UNITS_BYTES);
+        RECORD_BYTES(resident_fast, ResidentFast);
-        RECORD(MEMORY_RESIDENT_PEAK, ResidentPeak, UNITS_BYTES);
+        RECORD_BYTES(resident_peak, ResidentPeak);
 // Although we can measure unique memory on MacOS we choose not to, because
 // doing so is too slow for telemetry.
 #ifndef XP_MACOSX
-        RECORD(MEMORY_UNIQUE, ResidentUnique, UNITS_BYTES);
+        RECORD_BYTES(unique, ResidentUnique);
 #endif
 
         if (completionRunnable) {
@@ -556,8 +495,7 @@ nsresult MemoryTelemetry::FinishGatheringTotalMemory(
   // detailed explaination see:
   // https://groups.google.com/a/mozilla.org/g/dev-platform/c/WGNOtjHdsdA
   if (aTotalMemory) {
-    HandleMemoryReport(Telemetry::MEMORY_TOTAL, nsIMemoryReporter::UNITS_BYTES,
+    glean::memory::total.Accumulate(aTotalMemory.value() / 1024);
-                       aTotalMemory.value());
   }
 
   if (aChildSizes.Length() > 1) {
@@ -594,8 +532,8 @@ nsresult MemoryTelemetry::FinishGatheringTotalMemory(
     for (auto size : aChildSizes) {
       int64_t diff = llabs(size - mean) * 100 / mean;
 
-      HandleMemoryReport(Telemetry::MEMORY_DISTRIBUTION_AMONG_CONTENT,
+      glean::memory::distribution_among_content.Get(key).AccumulateSingleSample(
-                         nsIMemoryReporter::UNITS_COUNT, diff, key);
+          diff);
     }
   }
 

xpcom/base/nsMemoryReporterManager.cpp

@@ -36,7 +36,7 @@
 #include "mozilla/RDDProcessManager.h"
 #include "mozilla/ResultExtensions.h"
 #include "mozilla/Services.h"
-#include "mozilla/Telemetry.h"
+#include "mozilla/glean/XpcomMetrics.h"
 #include "mozilla/UniquePtrExtensions.h"
 #include "mozilla/dom/MemoryReportTypes.h"
 #include "mozilla/dom/ContentParent.h"
@@ -417,7 +417,7 @@ static void XMappingIter(int64_t& aVsize, int64_t& aResident,
                                                                 bool aDoPurge) {
 #  ifdef HAVE_JEMALLOC_STATS
   if (aDoPurge) {
-    Telemetry::AutoTimer<Telemetry::MEMORY_FREE_PURGED_PAGES_MS> timer;
+    auto timer = glean::memory::free_purged_pages.Measure();
     jemalloc_purge_freed_pages();
   }
 #  endif

xpcom/metrics.yaml

@@ -469,3 +469,435 @@ cycle_collector:
       - dev-telemetry-gc-alerts@mozilla.org
     expires: never
     telemetry_mirror: DEFERRED_FINALIZE_ASYNC
+
+memory:
+  resident_fast:
+    type: memory_distribution
+    description: >
+      Resident memory size (KB)
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_RESIDENT_FAST.
+    memory_unit: kilobyte
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1226196
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1870550
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1226196
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1870550
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_RESIDENT_FAST
+
+  resident_peak:
+    type: memory_distribution
+    description: >
+      Peak resident memory size (KB)
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_RESIDENT_PEAK.
+    memory_unit: kilobyte
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1551648
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1870550
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1551648
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1870550
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+      - amccreight@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_RESIDENT_PEAK
+
+  total:
+    type: memory_distribution
+    description: >
+      Total Memory Across All Processes (KB) (inaccurate WRT shared memory. See
+      MemoryTelemetry.cpp)
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_TOTAL.
+    memory_unit: kilobyte
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1198209
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1511918
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1198209
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1511918
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+      - amccreight@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_TOTAL
+
+  distribution_among_content:
+    type: labeled_custom_distribution
+    description: >
+      Absolute difference of each content process' USS and the mean of USS's,
+      normalized by the mean, in percentage. It will be recorded with the rest
+      of the memory probes when gatherMemory is called, if at least 2 content
+      processes are alive. Example: in case of 4 content processes with USS's:
+      1G, 500MB, 1G, 1.5G, the reported numbers will be: 0, 50, 0, 50. Which
+      indicates that 2 processes used 50% more or 50% less memory than the
+      avarage and 2 used exactly as much as the avarage.
+
+      This metric was generated to correspond to the Legacy Telemetry linear
+      histogram MEMORY_DISTRIBUTION_AMONG_CONTENT.
+    range_min: 1
+    range_max: 200
+    bucket_count: 100
+    histogram_type: linear
+    unit: percentage
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1344174
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1344174
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_DISTRIBUTION_AMONG_CONTENT
+
+  unique:
+    type: memory_distribution
+    description: >
+      Unique Set Size (KB)
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_UNIQUE.
+    memory_unit: kilobyte
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1198209
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1870550
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1198209
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1870550
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_UNIQUE
+
+  vsize:
+    type: memory_distribution
+    description: >
+      Virtual memory size (KB)
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_VSIZE.
+    memory_unit: kilobyte
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_VSIZE
+
+  vsize_max_contiguous:
+    type: memory_distribution
+    description: >
+      Maximum-sized block of contiguous virtual memory (KB)
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_VSIZE_MAX_CONTIGUOUS.
+    memory_unit: kilobyte
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_VSIZE_MAX_CONTIGUOUS
+
+  js_compartments_system:
+    type: custom_distribution
+    description: >
+      Total JavaScript compartments used for add-ons and internals.
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_JS_COMPARTMENTS_SYSTEM.
+    range_min: 1
+    range_max: 1000
+    bucket_count: 50
+    histogram_type: exponential
+    unit: compartments
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_JS_COMPARTMENTS_SYSTEM
+
+  js_compartments_user:
+    type: custom_distribution
+    description: >
+      Total JavaScript compartments used for web pages
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_JS_COMPARTMENTS_USER.
+    range_min: 1
+    range_max: 1000
+    bucket_count: 50
+    histogram_type: exponential
+    unit: compartments
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_JS_COMPARTMENTS_USER
+
+  js_realms_system:
+    type: custom_distribution
+    description: >
+      Total JavaScript realms used for add-ons and internals.
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_JS_REALMS_SYSTEM.
+    range_min: 1
+    range_max: 1000
+    bucket_count: 50
+    histogram_type: exponential
+    unit: realms
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1518077
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1518077
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+      - jdemooij@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_JS_REALMS_SYSTEM
+
+  js_realms_user:
+    type: custom_distribution
+    description: >
+      Total JavaScript realms used for web pages.
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_JS_REALMS_USER.
+    range_min: 1
+    range_max: 1000
+    bucket_count: 50
+    histogram_type: exponential
+    unit: realms
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1518077
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1518077
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+      - jdemooij@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_JS_REALMS_USER
+
+  js_gc_heap:
+    type: memory_distribution
+    description: >
+      Memory used by the garbage-collected JavaScript heap (KB)
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_JS_GC_HEAP.
+    memory_unit: kilobyte
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_JS_GC_HEAP
+
+  storage_sqlite:
+    type: memory_distribution
+    description: >
+      Memory used by SQLite (KB)
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_STORAGE_SQLITE.
+    memory_unit: kilobyte
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_STORAGE_SQLITE
+
+  images_content_used_uncompressed:
+    type: memory_distribution
+    description: >
+      Memory used for uncompressed, in-use content images (KB)
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_IMAGES_CONTENT_USED_UNCOMPRESSED.
+    memory_unit: kilobyte
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_IMAGES_CONTENT_USED_UNCOMPRESSED
+
+  heap_allocated:
+    type: memory_distribution
+    description: >
+      Heap memory allocated (KB)
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_HEAP_ALLOCATED.
+    memory_unit: kilobyte
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_HEAP_ALLOCATED
+
+  heap_overhead_fraction:
+    type: custom_distribution
+    description: >
+      Fraction of committed heap memory that is overhead (percentage).
+
+      This metric was generated to correspond to the Legacy Telemetry linear
+      histogram MEMORY_HEAP_OVERHEAD_FRACTION.
+    range_min: 1
+    range_max: 100
+    bucket_count: 25
+    histogram_type: linear
+    unit: percentage
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1252375
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1252375
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_HEAP_OVERHEAD_FRACTION
+
+  ghost_windows:
+    type: custom_distribution
+    description: >
+      Number of ghost windows
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram GHOST_WINDOWS.
+    range_min: 1
+    range_max: 128
+    bucket_count: 32
+    histogram_type: exponential
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: GHOST_WINDOWS
+
+  low_memory_events_physical:
+    type: custom_distribution
+    description: >
+      Number of low-physical-memory events fired since last ping
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram LOW_MEMORY_EVENTS_PHYSICAL.
+    range_min: 1
+    range_max: 1024
+    bucket_count: 21
+    histogram_type: exponential
+    unit: events
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=711490
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1451005
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=711490
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1451005
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: LOW_MEMORY_EVENTS_PHYSICAL
+
+  page_faults_hard:
+    type: custom_distribution
+    description: >
+      Hard page faults (since last telemetry ping)
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram PAGE_FAULTS_HARD.
+    range_min: 8
+    range_max: 65536
+    bucket_count: 13
+    histogram_type: exponential
+    unit: page faults
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: PAGE_FAULTS_HARD
+
+  collection_time:
+    type: timing_distribution
+    description: >
+      Time spent gathering memory telemetry in milliseconds
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_COLLECTION_TIME.
+    time_unit: millisecond
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1786864
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1786864
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_COLLECTION_TIME
+
+  free_purged_pages:
+    type: timing_distribution
+    description: >
+      Time(ms) to purge dirty heap pages.
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_FREE_PURGED_PAGES_MS.
+    time_unit: millisecond
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1950710
+    notification_emails:
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_FREE_PURGED_PAGES_MS
+
+  unique_content_startup:
+    type: memory_distribution
+    description: >
+      Unique Set Size of Content Process at Startup (KB)
+
+      This metric was generated to correspond to the Legacy Telemetry
+      exponential histogram MEMORY_UNIQUE_CONTENT_STARTUP.
+    memory_unit: kilobyte
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1494827
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1494827
+    notification_emails:
+      - amccreight@mozilla.com
+      - memshrink-telemetry-alerts@mozilla.com
+    expires: never
+    telemetry_mirror: MEMORY_UNIQUE_CONTENT_STARTUP