From 55c6fd3ae2bf2389517d548b54a2ae6fdc8c6ad1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Florian=20Qu=C3=A8ze?= Date: Thu, 20 Mar 2025 19:54:58 +0000 Subject: [PATCH] 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 | 4 +- toolkit/components/telemetry/Histograms.json | 22 - xpcom/base/MemoryTelemetry.cpp | 164 +++---- xpcom/base/nsMemoryReporterManager.cpp | 4 +- xpcom/metrics.yaml | 432 +++++++++++++++++++ 5 files changed, 487 insertions(+), 139 deletions(-) diff --git a/js/xpconnect/loader/ScriptPreloader.cpp b/js/xpconnect/loader/ScriptPreloader.cpp index d2dd4c0b6207..41a4de15bb51 100644 --- a/js/xpconnect/loader/ScriptPreloader.cpp +++ b/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::Telemetry::MEMORY_UNIQUE_CONTENT_STARTUP, + mozilla::glean::memory::unique_content_startup.Accumulate( nsMemoryReporterManager::ResidentUnique() / 1024); } #endif diff --git a/toolkit/components/telemetry/Histograms.json b/toolkit/components/telemetry/Histograms.json index d6d32a9ef3fb..dc954446e332 100644 --- a/toolkit/components/telemetry/Histograms.json +++ b/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"], diff --git a/xpcom/base/MemoryTelemetry.cpp b/xpcom/base/MemoryTelemetry.cpp index f1371314ef43..ae7a9d56e94d 100644 --- a/xpcom/base/MemoryTelemetry.cpp +++ b/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_COMMIT_SPACE, - LOW_MEMORY_EVENTS_PHYSICAL, + 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& 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) \ - do { \ - int64_t amt; \ - nsresult rv = mgr->Get##metric(&amt); \ - if (NS_SUCCEEDED(rv)) { \ - HandleMemoryReport(Telemetry::id, nsIMemoryReporter::units, amt); \ - } else if (rv != NS_ERROR_NOT_AVAILABLE) { \ - NS_WARNING("Failed to retrieve memory telemetry for " #metric); \ - } \ +#define RECORD_OUTER(metric, inner) \ + do { \ + int64_t amt; \ + nsresult rv = mgr->Get##metric(&amt); \ + if (NS_SUCCEEDED(rv)) { \ + inner \ + } else if (rv != NS_ERROR_NOT_AVAILABLE) { \ + 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(MEMORY_JS_COMPARTMENTS_SYSTEM, JSMainRuntimeCompartmentsSystem, - UNITS_COUNT); - RECORD(MEMORY_JS_COMPARTMENTS_USER, JSMainRuntimeCompartmentsUser, - UNITS_COUNT); - RECORD(MEMORY_JS_REALMS_SYSTEM, JSMainRuntimeRealmsSystem, UNITS_COUNT); - RECORD(MEMORY_JS_REALMS_USER, JSMainRuntimeRealmsUser, UNITS_COUNT); - RECORD(MEMORY_IMAGES_CONTENT_USED_UNCOMPRESSED, ImagesContentUsedUncompressed, - UNITS_BYTES); - RECORD(MEMORY_STORAGE_SQLITE, StorageSQLite, UNITS_BYTES); + RECORD_BYTES(js_gc_heap, JSMainRuntimeGCHeap); + RECORD_COUNT(js_compartments_system, JSMainRuntimeCompartmentsSystem); + RECORD_COUNT(js_compartments_user, JSMainRuntimeCompartmentsUser); + RECORD_COUNT(js_realms_system, JSMainRuntimeRealmsSystem); + RECORD_COUNT(js_realms_user, JSMainRuntimeRealmsUser); + RECORD_BYTES(images_content_used_uncompressed, ImagesContentUsedUncompressed); + RECORD_BYTES(storage_sqlite, StorageSQLite); #ifdef XP_WIN - RECORD(LOW_MEMORY_EVENTS_PHYSICAL, LowMemoryEventsPhysical, - UNITS_COUNT_CUMULATIVE); + RECORD_COUNT_CUMULATIVE(low_memory_events_physical, LowMemoryEventsPhysical); #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, - nsIMemoryReporter::UNITS_BYTES, mgr->HeapAllocated(stats)); - HandleMemoryReport(Telemetry::MEMORY_HEAP_OVERHEAD_FRACTION, - nsIMemoryReporter::UNITS_PERCENTAGE, - mgr->HeapOverheadFraction(stats)); + glean::memory::heap_allocated.Accumulate(mgr->HeapAllocated(stats) / 1024); + glean::memory::heap_overhead_fraction.AccumulateSingleSample( + mgr->HeapOverheadFraction(stats) / 100); #endif #ifdef MOZ_PHC @@ -408,17 +347,17 @@ nsresult MemoryTelemetry::GatherReports( // asynchronously, on a background thread. RefPtr runnable = NS_NewRunnableFunction( "MemoryTelemetry::GatherReports", [mgr, completionRunnable]() mutable { - Telemetry::AutoTimer autoTimer; - RECORD(MEMORY_VSIZE, Vsize, UNITS_BYTES); + auto timer = glean::memory::collection_time.Measure(); + 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(MEMORY_RESIDENT_PEAK, ResidentPeak, UNITS_BYTES); + RECORD_BYTES(resident_fast, ResidentFast); + 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, - aTotalMemory.value()); + glean::memory::total.Accumulate(aTotalMemory.value() / 1024); } 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, - nsIMemoryReporter::UNITS_COUNT, diff, key); + glean::memory::distribution_among_content.Get(key).AccumulateSingleSample( + diff); } } diff --git a/xpcom/base/nsMemoryReporterManager.cpp b/xpcom/base/nsMemoryReporterManager.cpp index 20f5c50528cb..b87240019712 100644 --- a/xpcom/base/nsMemoryReporterManager.cpp +++ b/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 timer; + auto timer = glean::memory::free_purged_pages.Measure(); jemalloc_purge_freed_pages(); } # endif diff --git a/xpcom/metrics.yaml b/xpcom/metrics.yaml index e9a2db127304..90260f8876af 100644 --- a/xpcom/metrics.yaml +++ b/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