/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* 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/. */ #include <algorithm> #include <fstream> #include <prio.h> #include "mozilla/dom/ToJSValue.h" #include "mozilla/Atomics.h" #include "mozilla/Attributes.h" #include "mozilla/DebugOnly.h" #include "mozilla/Likely.h" #include "mozilla/MathAlgorithms.h" #include "mozilla/Unused.h" #include "base/pickle.h" #include "nsIComponentManager.h" #include "nsIServiceManager.h" #include "nsThreadManager.h" #include "nsCOMArray.h" #include "nsCOMPtr.h" #include "nsXPCOMPrivate.h" #include "nsIXULAppInfo.h" #include "nsVersionComparator.h" #include "mozilla/MemoryReporting.h" #include "mozilla/ModuleUtils.h" #include "nsIXPConnect.h" #include "mozilla/Services.h" #include "jsapi.h" #include "jsfriendapi.h" #include "js/GCAPI.h" #include "nsString.h" #include "nsITelemetry.h" #include "nsIFile.h" #include "nsIFileStreams.h" #include "nsIMemoryReporter.h" #include "nsISeekableStream.h" #include "Telemetry.h" #include "TelemetryCommon.h" #include "TelemetryHistogram.h" #include "TelemetryScalar.h" #include "TelemetryEvent.h" #include "WebrtcTelemetry.h" #include "nsTHashtable.h" #include "nsHashKeys.h" #include "nsBaseHashtable.h" #include "nsClassHashtable.h" #include "nsXULAppAPI.h" #include "nsReadableUtils.h" #include "nsThreadUtils.h" #if defined(XP_WIN) #include "nsUnicharUtils.h" #endif #include "nsNetCID.h" #include "nsNetUtil.h" #include "nsJSUtils.h" #include "nsReadableUtils.h" #include "plstr.h" #include "nsAppDirectoryServiceDefs.h" #include "mozilla/BackgroundHangMonitor.h" #include "mozilla/ThreadHangStats.h" #include "mozilla/ProcessedStack.h" #include "mozilla/Mutex.h" #include "mozilla/FileUtils.h" #include "mozilla/Preferences.h" #include "mozilla/StaticPtr.h" #include "mozilla/IOInterposer.h" #include "mozilla/PoisonIOInterposer.h" #include "mozilla/StartupTimeline.h" #include "mozilla/HangMonitor.h" namespace { using namespace mozilla; using namespace mozilla::HangMonitor; using Telemetry::Common::AutoHashtable; // The maximum number of chrome hangs stacks that we're keeping. const size_t kMaxChromeStacksKept = 50; // The maximum depth of a single chrome hang stack. const size_t kMaxChromeStackDepth = 50; // This class is conceptually a list of ProcessedStack objects, but it represents them // more efficiently by keeping a single global list of modules. class CombinedStacks { public: CombinedStacks() : mNextIndex(0) {} typedef std::vector<Telemetry::ProcessedStack::Frame> Stack; const Telemetry::ProcessedStack::Module& GetModule(unsigned aIndex) const; size_t GetModuleCount() const; const Stack& GetStack(unsigned aIndex) const; size_t AddStack(const Telemetry::ProcessedStack& aStack); size_t GetStackCount() const; size_t SizeOfExcludingThis() const; private: std::vector<Telemetry::ProcessedStack::Module> mModules; // A circular buffer to hold the stacks. std::vector<Stack> mStacks; // The index of the next buffer element to write to in mStacks. size_t mNextIndex; }; static JSObject * CreateJSStackObject(JSContext *cx, const CombinedStacks &stacks); size_t CombinedStacks::GetModuleCount() const { return mModules.size(); } const Telemetry::ProcessedStack::Module& CombinedStacks::GetModule(unsigned aIndex) const { return mModules[aIndex]; } size_t CombinedStacks::AddStack(const Telemetry::ProcessedStack& aStack) { // Advance the indices of the circular queue holding the stacks. size_t index = mNextIndex++ % kMaxChromeStacksKept; // Grow the vector up to the maximum size, if needed. if (mStacks.size() < kMaxChromeStacksKept) { mStacks.resize(mStacks.size() + 1); } // Get a reference to the location holding the new stack. CombinedStacks::Stack& adjustedStack = mStacks[index]; // If we're using an old stack to hold aStack, clear it. adjustedStack.clear(); size_t stackSize = aStack.GetStackSize(); for (size_t i = 0; i < stackSize; ++i) { const Telemetry::ProcessedStack::Frame& frame = aStack.GetFrame(i); uint16_t modIndex; if (frame.mModIndex == std::numeric_limits<uint16_t>::max()) { modIndex = frame.mModIndex; } else { const Telemetry::ProcessedStack::Module& module = aStack.GetModule(frame.mModIndex); std::vector<Telemetry::ProcessedStack::Module>::iterator modIterator = std::find(mModules.begin(), mModules.end(), module); if (modIterator == mModules.end()) { mModules.push_back(module); modIndex = mModules.size() - 1; } else { modIndex = modIterator - mModules.begin(); } } Telemetry::ProcessedStack::Frame adjustedFrame = { frame.mOffset, modIndex }; adjustedStack.push_back(adjustedFrame); } return index; } const CombinedStacks::Stack& CombinedStacks::GetStack(unsigned aIndex) const { return mStacks[aIndex]; } size_t CombinedStacks::GetStackCount() const { return mStacks.size(); } size_t CombinedStacks::SizeOfExcludingThis() const { // This is a crude approximation. We would like to do something like // aMallocSizeOf(&mModules[0]), but on linux aMallocSizeOf will call // malloc_usable_size which is only safe on the pointers returned by malloc. // While it works on current libstdc++, it is better to be safe and not assume // that &vec[0] points to one. We could use a custom allocator, but // it doesn't seem worth it. size_t n = 0; n += mModules.capacity() * sizeof(Telemetry::ProcessedStack::Module); n += mStacks.capacity() * sizeof(Stack); for (std::vector<Stack>::const_iterator i = mStacks.begin(), e = mStacks.end(); i != e; ++i) { const Stack& s = *i; n += s.capacity() * sizeof(Telemetry::ProcessedStack::Frame); } return n; } // This utility function generates a string key that is used to index the annotations // in a hash map from |HangReports::AddHang|. nsresult ComputeAnnotationsKey(const HangAnnotationsPtr& aAnnotations, nsAString& aKeyOut) { UniquePtr<HangAnnotations::Enumerator> annotationsEnum = aAnnotations->GetEnumerator(); if (!annotationsEnum) { return NS_ERROR_FAILURE; } // Append all the attributes to the key, to uniquely identify this annotation. nsAutoString key; nsAutoString value; while (annotationsEnum->Next(key, value)) { aKeyOut.Append(key); aKeyOut.Append(value); } return NS_OK; } class HangReports { public: /** * This struct encapsulates information for an individual ChromeHang annotation. * mHangIndex is the index of the corresponding ChromeHang. */ struct AnnotationInfo { AnnotationInfo(uint32_t aHangIndex, HangAnnotationsPtr aAnnotations) : mAnnotations(Move(aAnnotations)) { mHangIndices.AppendElement(aHangIndex); } AnnotationInfo(AnnotationInfo&& aOther) : mHangIndices(aOther.mHangIndices) , mAnnotations(Move(aOther.mAnnotations)) {} ~AnnotationInfo() {} AnnotationInfo& operator=(AnnotationInfo&& aOther) { mHangIndices = aOther.mHangIndices; mAnnotations = Move(aOther.mAnnotations); return *this; } // To save memory, a single AnnotationInfo can be associated to multiple chrome // hangs. The following array holds the index of each related chrome hang. nsTArray<uint32_t> mHangIndices; HangAnnotationsPtr mAnnotations; private: // Force move constructor AnnotationInfo(const AnnotationInfo& aOther) = delete; void operator=(const AnnotationInfo& aOther) = delete; }; size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const; void AddHang(const Telemetry::ProcessedStack& aStack, uint32_t aDuration, int32_t aSystemUptime, int32_t aFirefoxUptime, HangAnnotationsPtr aAnnotations); void PruneStackReferences(const size_t aRemovedStackIndex); uint32_t GetDuration(unsigned aIndex) const; int32_t GetSystemUptime(unsigned aIndex) const; int32_t GetFirefoxUptime(unsigned aIndex) const; const nsClassHashtable<nsStringHashKey, AnnotationInfo>& GetAnnotationInfo() const; const CombinedStacks& GetStacks() const; private: /** * This struct encapsulates the data for an individual ChromeHang, excluding * annotations. */ struct HangInfo { // Hang duration (in seconds) uint32_t mDuration; // System uptime (in minutes) at the time of the hang int32_t mSystemUptime; // Firefox uptime (in minutes) at the time of the hang int32_t mFirefoxUptime; }; std::vector<HangInfo> mHangInfo; nsClassHashtable<nsStringHashKey, AnnotationInfo> mAnnotationInfo; CombinedStacks mStacks; }; void HangReports::AddHang(const Telemetry::ProcessedStack& aStack, uint32_t aDuration, int32_t aSystemUptime, int32_t aFirefoxUptime, HangAnnotationsPtr aAnnotations) { // Append the new stack to the stack's circular queue. size_t hangIndex = mStacks.AddStack(aStack); // Append the hang info at the same index, in mHangInfo. HangInfo info = { aDuration, aSystemUptime, aFirefoxUptime }; if (mHangInfo.size() < kMaxChromeStacksKept) { mHangInfo.push_back(info); } else { mHangInfo[hangIndex] = info; // Remove any reference to the stack overwritten in the circular queue // from the annotations. PruneStackReferences(hangIndex); } if (!aAnnotations) { return; } nsAutoString annotationsKey; // Generate a key to index aAnnotations in the hash map. nsresult rv = ComputeAnnotationsKey(aAnnotations, annotationsKey); if (NS_FAILED(rv)) { return; } AnnotationInfo* annotationsEntry = mAnnotationInfo.Get(annotationsKey); if (annotationsEntry) { // If the key is already in the hash map, append the index of the chrome hang // to its indices. annotationsEntry->mHangIndices.AppendElement(hangIndex); return; } // If the key was not found, add the annotations to the hash map. mAnnotationInfo.Put(annotationsKey, new AnnotationInfo(hangIndex, Move(aAnnotations))); } /** * This function removes links to discarded chrome hangs stacks and prunes unused * annotations. */ void HangReports::PruneStackReferences(const size_t aRemovedStackIndex) { // We need to adjust the indices that link annotations to chrome hangs. Since we // removed a stack, we must remove all references to it and prune annotations // linked to no stacks. for (auto iter = mAnnotationInfo.Iter(); !iter.Done(); iter.Next()) { nsTArray<uint32_t>& stackIndices = iter.Data()->mHangIndices; size_t toRemove = stackIndices.NoIndex; for (size_t k = 0; k < stackIndices.Length(); k++) { // Is this index referencing the removed stack? if (stackIndices[k] == aRemovedStackIndex) { toRemove = k; break; } } // Remove the index referencing the old stack from the annotation. if (toRemove != stackIndices.NoIndex) { stackIndices.RemoveElementAt(toRemove); } // If this annotation no longer references any stack, drop it. if (!stackIndices.Length()) { iter.Remove(); } } } size_t HangReports::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const { size_t n = 0; n += mStacks.SizeOfExcludingThis(); // This is a crude approximation. See comment on // CombinedStacks::SizeOfExcludingThis. n += mHangInfo.capacity() * sizeof(HangInfo); n += mAnnotationInfo.ShallowSizeOfExcludingThis(aMallocSizeOf); n += mAnnotationInfo.Count() * sizeof(AnnotationInfo); for (auto iter = mAnnotationInfo.ConstIter(); !iter.Done(); iter.Next()) { n += iter.Key().SizeOfExcludingThisIfUnshared(aMallocSizeOf); n += iter.Data()->mAnnotations->SizeOfIncludingThis(aMallocSizeOf); } return n; } const CombinedStacks& HangReports::GetStacks() const { return mStacks; } uint32_t HangReports::GetDuration(unsigned aIndex) const { return mHangInfo[aIndex].mDuration; } int32_t HangReports::GetSystemUptime(unsigned aIndex) const { return mHangInfo[aIndex].mSystemUptime; } int32_t HangReports::GetFirefoxUptime(unsigned aIndex) const { return mHangInfo[aIndex].mFirefoxUptime; } const nsClassHashtable<nsStringHashKey, HangReports::AnnotationInfo>& HangReports::GetAnnotationInfo() const { return mAnnotationInfo; } /** * IOInterposeObserver recording statistics of main-thread I/O during execution, * aimed at consumption by TelemetryImpl */ class TelemetryIOInterposeObserver : public IOInterposeObserver { /** File-level statistics structure */ struct FileStats { FileStats() : creates(0) , reads(0) , writes(0) , fsyncs(0) , stats(0) , totalTime(0) {} uint32_t creates; /** Number of create/open operations */ uint32_t reads; /** Number of read operations */ uint32_t writes; /** Number of write operations */ uint32_t fsyncs; /** Number of fsync operations */ uint32_t stats; /** Number of stat operations */ double totalTime; /** Accumulated duration of all operations */ }; struct SafeDir { SafeDir(const nsAString& aPath, const nsAString& aSubstName) : mPath(aPath) , mSubstName(aSubstName) {} size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const { return mPath.SizeOfExcludingThisIfUnshared(aMallocSizeOf) + mSubstName.SizeOfExcludingThisIfUnshared(aMallocSizeOf); } nsString mPath; /** Path to the directory */ nsString mSubstName; /** Name to substitute with */ }; public: explicit TelemetryIOInterposeObserver(nsIFile* aXreDir); /** * An implementation of Observe that records statistics of all * file IO operations. */ void Observe(Observation& aOb); /** * Reflect recorded file IO statistics into Javascript */ bool ReflectIntoJS(JSContext *cx, JS::Handle<JSObject*> rootObj); /** * Adds a path for inclusion in main thread I/O report. * @param aPath Directory path * @param aSubstName Name to substitute for aPath for privacy reasons */ void AddPath(const nsAString& aPath, const nsAString& aSubstName); /** * Get size of hash table with file stats */ size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const { return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); } size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const { size_t size = 0; size += mFileStats.ShallowSizeOfExcludingThis(aMallocSizeOf); for (auto iter = mFileStats.ConstIter(); !iter.Done(); iter.Next()) { size += iter.Get()->GetKey().SizeOfExcludingThisIfUnshared(aMallocSizeOf); } size += mSafeDirs.ShallowSizeOfExcludingThis(aMallocSizeOf); uint32_t safeDirsLen = mSafeDirs.Length(); for (uint32_t i = 0; i < safeDirsLen; ++i) { size += mSafeDirs[i].SizeOfExcludingThis(aMallocSizeOf); } return size; } private: enum Stage { STAGE_STARTUP = 0, STAGE_NORMAL, STAGE_SHUTDOWN, NUM_STAGES }; static inline Stage NextStage(Stage aStage) { switch (aStage) { case STAGE_STARTUP: return STAGE_NORMAL; case STAGE_NORMAL: return STAGE_SHUTDOWN; case STAGE_SHUTDOWN: return STAGE_SHUTDOWN; default: return NUM_STAGES; } } struct FileStatsByStage { FileStats mStats[NUM_STAGES]; }; typedef nsBaseHashtableET<nsStringHashKey, FileStatsByStage> FileIOEntryType; // Statistics for each filename AutoHashtable<FileIOEntryType> mFileStats; // Container for whitelisted directories nsTArray<SafeDir> mSafeDirs; Stage mCurStage; /** * Reflect a FileIOEntryType object to a Javascript property on obj with * filename as key containing array: * [totalTime, creates, reads, writes, fsyncs, stats] */ static bool ReflectFileStats(FileIOEntryType* entry, JSContext *cx, JS::Handle<JSObject*> obj); }; TelemetryIOInterposeObserver::TelemetryIOInterposeObserver(nsIFile* aXreDir) : mCurStage(STAGE_STARTUP) { nsAutoString xreDirPath; nsresult rv = aXreDir->GetPath(xreDirPath); if (NS_SUCCEEDED(rv)) { AddPath(xreDirPath, NS_LITERAL_STRING("{xre}")); } } void TelemetryIOInterposeObserver::AddPath(const nsAString& aPath, const nsAString& aSubstName) { mSafeDirs.AppendElement(SafeDir(aPath, aSubstName)); } // Threshold for reporting slow main-thread I/O (50 milliseconds). const TimeDuration kTelemetryReportThreshold = TimeDuration::FromMilliseconds(50); void TelemetryIOInterposeObserver::Observe(Observation& aOb) { // We only report main-thread I/O if (!IsMainThread()) { return; } if (aOb.ObservedOperation() == OpNextStage) { mCurStage = NextStage(mCurStage); MOZ_ASSERT(mCurStage < NUM_STAGES); return; } if (aOb.Duration() < kTelemetryReportThreshold) { return; } // Get the filename const char16_t* filename = aOb.Filename(); // Discard observations without filename if (!filename) { return; } #if defined(XP_WIN) nsCaseInsensitiveStringComparator comparator; #else nsDefaultStringComparator comparator; #endif nsAutoString processedName; nsDependentString filenameStr(filename); uint32_t safeDirsLen = mSafeDirs.Length(); for (uint32_t i = 0; i < safeDirsLen; ++i) { if (StringBeginsWith(filenameStr, mSafeDirs[i].mPath, comparator)) { processedName = mSafeDirs[i].mSubstName; processedName += Substring(filenameStr, mSafeDirs[i].mPath.Length()); break; } } if (processedName.IsEmpty()) { return; } // Create a new entry or retrieve the existing one FileIOEntryType* entry = mFileStats.PutEntry(processedName); if (entry) { FileStats& stats = entry->mData.mStats[mCurStage]; // Update the statistics stats.totalTime += (double) aOb.Duration().ToMilliseconds(); switch (aOb.ObservedOperation()) { case OpCreateOrOpen: stats.creates++; break; case OpRead: stats.reads++; break; case OpWrite: stats.writes++; break; case OpFSync: stats.fsyncs++; break; case OpStat: stats.stats++; break; default: break; } } } bool TelemetryIOInterposeObserver::ReflectFileStats(FileIOEntryType* entry, JSContext *cx, JS::Handle<JSObject*> obj) { JS::AutoValueArray<NUM_STAGES> stages(cx); FileStatsByStage& statsByStage = entry->mData; for (int s = STAGE_STARTUP; s < NUM_STAGES; ++s) { FileStats& fileStats = statsByStage.mStats[s]; if (fileStats.totalTime == 0 && fileStats.creates == 0 && fileStats.reads == 0 && fileStats.writes == 0 && fileStats.fsyncs == 0 && fileStats.stats == 0) { // Don't add an array that contains no information stages[s].setNull(); continue; } // Array we want to report JS::AutoValueArray<6> stats(cx); stats[0].setNumber(fileStats.totalTime); stats[1].setNumber(fileStats.creates); stats[2].setNumber(fileStats.reads); stats[3].setNumber(fileStats.writes); stats[4].setNumber(fileStats.fsyncs); stats[5].setNumber(fileStats.stats); // Create jsStats as array of elements above JS::RootedObject jsStats(cx, JS_NewArrayObject(cx, stats)); if (!jsStats) { continue; } stages[s].setObject(*jsStats); } JS::Rooted<JSObject*> jsEntry(cx, JS_NewArrayObject(cx, stages)); if (!jsEntry) { return false; } // Add jsEntry to top-level dictionary const nsAString& key = entry->GetKey(); return JS_DefineUCProperty(cx, obj, key.Data(), key.Length(), jsEntry, JSPROP_ENUMERATE | JSPROP_READONLY); } bool TelemetryIOInterposeObserver::ReflectIntoJS(JSContext *cx, JS::Handle<JSObject*> rootObj) { return mFileStats.ReflectIntoJS(ReflectFileStats, cx, rootObj); } // This is not a member of TelemetryImpl because we want to record I/O during // startup. StaticAutoPtr<TelemetryIOInterposeObserver> sTelemetryIOObserver; void ClearIOReporting() { if (!sTelemetryIOObserver) { return; } IOInterposer::Unregister(IOInterposeObserver::OpAllWithStaging, sTelemetryIOObserver); sTelemetryIOObserver = nullptr; } class TelemetryImpl final : public nsITelemetry , public nsIMemoryReporter { NS_DECL_THREADSAFE_ISUPPORTS NS_DECL_NSITELEMETRY NS_DECL_NSIMEMORYREPORTER public: void InitMemoryReporter(); static already_AddRefed<nsITelemetry> CreateTelemetryInstance(); static void ShutdownTelemetry(); static void RecordSlowStatement(const nsACString &sql, const nsACString &dbName, uint32_t delay); static void RecordThreadHangStats(Telemetry::ThreadHangStats& aStats); size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf); struct Stat { uint32_t hitCount; uint32_t totalTime; }; struct StmtStats { struct Stat mainThread; struct Stat otherThreads; }; typedef nsBaseHashtableET<nsCStringHashKey, StmtStats> SlowSQLEntryType; static void RecordIceCandidates(const uint32_t iceCandidateBitmask, const bool success); private: TelemetryImpl(); ~TelemetryImpl(); static nsCString SanitizeSQL(const nsACString& sql); enum SanitizedState { Sanitized, Unsanitized }; static void StoreSlowSQL(const nsACString &offender, uint32_t delay, SanitizedState state); static bool ReflectMainThreadSQL(SlowSQLEntryType *entry, JSContext *cx, JS::Handle<JSObject*> obj); static bool ReflectOtherThreadsSQL(SlowSQLEntryType *entry, JSContext *cx, JS::Handle<JSObject*> obj); static bool ReflectSQL(const SlowSQLEntryType *entry, const Stat *stat, JSContext *cx, JS::Handle<JSObject*> obj); bool AddSQLInfo(JSContext *cx, JS::Handle<JSObject*> rootObj, bool mainThread, bool privateSQL); bool GetSQLStats(JSContext *cx, JS::MutableHandle<JS::Value> ret, bool includePrivateSql); void ReadLateWritesStacks(nsIFile* aProfileDir); static TelemetryImpl *sTelemetry; AutoHashtable<SlowSQLEntryType> mPrivateSQL; AutoHashtable<SlowSQLEntryType> mSanitizedSQL; Mutex mHashMutex; HangReports mHangReports; Mutex mHangReportsMutex; // mThreadHangStats stores recorded, inactive thread hang stats Vector<Telemetry::ThreadHangStats> mThreadHangStats; Mutex mThreadHangStatsMutex; CombinedStacks mLateWritesStacks; // This is collected out of the main thread. bool mCachedTelemetryData; uint32_t mLastShutdownTime; uint32_t mFailedLockCount; nsCOMArray<nsIFetchTelemetryDataCallback> mCallbacks; friend class nsFetchTelemetryData; WebrtcTelemetry mWebrtcTelemetry; }; TelemetryImpl* TelemetryImpl::sTelemetry = nullptr; MOZ_DEFINE_MALLOC_SIZE_OF(TelemetryMallocSizeOf) NS_IMETHODIMP TelemetryImpl::CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData, bool aAnonymize) { MOZ_COLLECT_REPORT( "explicit/telemetry", KIND_HEAP, UNITS_BYTES, SizeOfIncludingThis(TelemetryMallocSizeOf), "Memory used by the telemetry system."); return NS_OK; } void InitHistogramRecordingEnabled() { TelemetryHistogram::InitHistogramRecordingEnabled(); } static uint32_t ReadLastShutdownDuration(const char *filename) { FILE *f = fopen(filename, "r"); if (!f) { return 0; } int shutdownTime; int r = fscanf(f, "%d\n", &shutdownTime); fclose(f); if (r != 1) { return 0; } return shutdownTime; } const int32_t kMaxFailedProfileLockFileSize = 10; bool GetFailedLockCount(nsIInputStream* inStream, uint32_t aCount, unsigned int& result) { nsAutoCString bufStr; nsresult rv; rv = NS_ReadInputStreamToString(inStream, bufStr, aCount); NS_ENSURE_SUCCESS(rv, false); result = bufStr.ToInteger(&rv); return NS_SUCCEEDED(rv) && result > 0; } nsresult GetFailedProfileLockFile(nsIFile* *aFile, nsIFile* aProfileDir) { NS_ENSURE_ARG_POINTER(aProfileDir); nsresult rv = aProfileDir->Clone(aFile); NS_ENSURE_SUCCESS(rv, rv); (*aFile)->AppendNative(NS_LITERAL_CSTRING("Telemetry.FailedProfileLocks.txt")); return NS_OK; } class nsFetchTelemetryData : public Runnable { public: nsFetchTelemetryData(const char* aShutdownTimeFilename, nsIFile* aFailedProfileLockFile, nsIFile* aProfileDir) : mShutdownTimeFilename(aShutdownTimeFilename), mFailedProfileLockFile(aFailedProfileLockFile), mTelemetry(TelemetryImpl::sTelemetry), mProfileDir(aProfileDir) { } private: const char* mShutdownTimeFilename; nsCOMPtr<nsIFile> mFailedProfileLockFile; RefPtr<TelemetryImpl> mTelemetry; nsCOMPtr<nsIFile> mProfileDir; public: void MainThread() { mTelemetry->mCachedTelemetryData = true; for (unsigned int i = 0, n = mTelemetry->mCallbacks.Count(); i < n; ++i) { mTelemetry->mCallbacks[i]->Complete(); } mTelemetry->mCallbacks.Clear(); } NS_IMETHOD Run() override { LoadFailedLockCount(mTelemetry->mFailedLockCount); mTelemetry->mLastShutdownTime = ReadLastShutdownDuration(mShutdownTimeFilename); mTelemetry->ReadLateWritesStacks(mProfileDir); nsCOMPtr<nsIRunnable> e = NewRunnableMethod(this, &nsFetchTelemetryData::MainThread); NS_ENSURE_STATE(e); NS_DispatchToMainThread(e); return NS_OK; } private: nsresult LoadFailedLockCount(uint32_t& failedLockCount) { failedLockCount = 0; int64_t fileSize = 0; nsresult rv = mFailedProfileLockFile->GetFileSize(&fileSize); if (NS_FAILED(rv)) { return rv; } NS_ENSURE_TRUE(fileSize <= kMaxFailedProfileLockFileSize, NS_ERROR_UNEXPECTED); nsCOMPtr<nsIInputStream> inStream; rv = NS_NewLocalFileInputStream(getter_AddRefs(inStream), mFailedProfileLockFile, PR_RDONLY); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_TRUE(GetFailedLockCount(inStream, fileSize, failedLockCount), NS_ERROR_UNEXPECTED); inStream->Close(); mFailedProfileLockFile->Remove(false); return NS_OK; } }; static TimeStamp gRecordedShutdownStartTime; static bool gAlreadyFreedShutdownTimeFileName = false; static char *gRecordedShutdownTimeFileName = nullptr; static char * GetShutdownTimeFileName() { if (gAlreadyFreedShutdownTimeFileName) { return nullptr; } if (!gRecordedShutdownTimeFileName) { nsCOMPtr<nsIFile> mozFile; NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(mozFile)); if (!mozFile) return nullptr; mozFile->AppendNative(NS_LITERAL_CSTRING("Telemetry.ShutdownTime.txt")); nsAutoCString nativePath; nsresult rv = mozFile->GetNativePath(nativePath); if (!NS_SUCCEEDED(rv)) return nullptr; gRecordedShutdownTimeFileName = PL_strdup(nativePath.get()); } return gRecordedShutdownTimeFileName; } NS_IMETHODIMP TelemetryImpl::GetLastShutdownDuration(uint32_t *aResult) { // The user must call AsyncFetchTelemetryData first. We return zero instead of // reporting a failure so that the rest of telemetry can uniformly handle // the read not being available yet. if (!mCachedTelemetryData) { *aResult = 0; return NS_OK; } *aResult = mLastShutdownTime; return NS_OK; } NS_IMETHODIMP TelemetryImpl::GetFailedProfileLockCount(uint32_t* aResult) { // The user must call AsyncFetchTelemetryData first. We return zero instead of // reporting a failure so that the rest of telemetry can uniformly handle // the read not being available yet. if (!mCachedTelemetryData) { *aResult = 0; return NS_OK; } *aResult = mFailedLockCount; return NS_OK; } NS_IMETHODIMP TelemetryImpl::AsyncFetchTelemetryData(nsIFetchTelemetryDataCallback *aCallback) { // We have finished reading the data already, just call the callback. if (mCachedTelemetryData) { aCallback->Complete(); return NS_OK; } // We already have a read request running, just remember the callback. if (mCallbacks.Count() != 0) { mCallbacks.AppendObject(aCallback); return NS_OK; } // We make this check so that GetShutdownTimeFileName() doesn't get // called; calling that function without telemetry enabled violates // assumptions that the write-the-shutdown-timestamp machinery makes. if (!Telemetry::CanRecordExtended()) { mCachedTelemetryData = true; aCallback->Complete(); return NS_OK; } // Send the read to a background thread provided by the stream transport // service to avoid a read in the main thread. nsCOMPtr<nsIEventTarget> targetThread = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID); if (!targetThread) { mCachedTelemetryData = true; aCallback->Complete(); return NS_OK; } // We have to get the filename from the main thread. const char *shutdownTimeFilename = GetShutdownTimeFileName(); if (!shutdownTimeFilename) { mCachedTelemetryData = true; aCallback->Complete(); return NS_OK; } nsCOMPtr<nsIFile> profileDir; nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(profileDir)); if (NS_FAILED(rv)) { mCachedTelemetryData = true; aCallback->Complete(); return NS_OK; } nsCOMPtr<nsIFile> failedProfileLockFile; rv = GetFailedProfileLockFile(getter_AddRefs(failedProfileLockFile), profileDir); if (NS_FAILED(rv)) { mCachedTelemetryData = true; aCallback->Complete(); return NS_OK; } mCallbacks.AppendObject(aCallback); nsCOMPtr<nsIRunnable> event = new nsFetchTelemetryData(shutdownTimeFilename, failedProfileLockFile, profileDir); targetThread->Dispatch(event, NS_DISPATCH_NORMAL); return NS_OK; } TelemetryImpl::TelemetryImpl() : mHashMutex("Telemetry::mHashMutex") , mHangReportsMutex("Telemetry::mHangReportsMutex") , mThreadHangStatsMutex("Telemetry::mThreadHangStatsMutex") , mCachedTelemetryData(false) , mLastShutdownTime(0) , mFailedLockCount(0) { // We expect TelemetryHistogram::InitializeGlobalState() to have been // called before we get to this point. MOZ_ASSERT(TelemetryHistogram::GlobalStateHasBeenInitialized()); } TelemetryImpl::~TelemetryImpl() { UnregisterWeakMemoryReporter(this); } void TelemetryImpl::InitMemoryReporter() { RegisterWeakMemoryReporter(this); } bool TelemetryImpl::ReflectSQL(const SlowSQLEntryType *entry, const Stat *stat, JSContext *cx, JS::Handle<JSObject*> obj) { if (stat->hitCount == 0) return true; const nsACString &sql = entry->GetKey(); JS::Rooted<JSObject*> arrayObj(cx, JS_NewArrayObject(cx, 0)); if (!arrayObj) { return false; } return (JS_DefineElement(cx, arrayObj, 0, stat->hitCount, JSPROP_ENUMERATE) && JS_DefineElement(cx, arrayObj, 1, stat->totalTime, JSPROP_ENUMERATE) && JS_DefineProperty(cx, obj, sql.BeginReading(), arrayObj, JSPROP_ENUMERATE)); } bool TelemetryImpl::ReflectMainThreadSQL(SlowSQLEntryType *entry, JSContext *cx, JS::Handle<JSObject*> obj) { return ReflectSQL(entry, &entry->mData.mainThread, cx, obj); } bool TelemetryImpl::ReflectOtherThreadsSQL(SlowSQLEntryType *entry, JSContext *cx, JS::Handle<JSObject*> obj) { return ReflectSQL(entry, &entry->mData.otherThreads, cx, obj); } bool TelemetryImpl::AddSQLInfo(JSContext *cx, JS::Handle<JSObject*> rootObj, bool mainThread, bool privateSQL) { JS::Rooted<JSObject*> statsObj(cx, JS_NewPlainObject(cx)); if (!statsObj) return false; AutoHashtable<SlowSQLEntryType>& sqlMap = (privateSQL ? mPrivateSQL : mSanitizedSQL); AutoHashtable<SlowSQLEntryType>::ReflectEntryFunc reflectFunction = (mainThread ? ReflectMainThreadSQL : ReflectOtherThreadsSQL); if (!sqlMap.ReflectIntoJS(reflectFunction, cx, statsObj)) { return false; } return JS_DefineProperty(cx, rootObj, mainThread ? "mainThread" : "otherThreads", statsObj, JSPROP_ENUMERATE); } NS_IMETHODIMP TelemetryImpl::RegisterAddonHistogram(const nsACString &id, const nsACString &name, uint32_t histogramType, uint32_t min, uint32_t max, uint32_t bucketCount, uint8_t optArgCount) { return TelemetryHistogram::RegisterAddonHistogram (id, name, histogramType, min, max, bucketCount, optArgCount); } NS_IMETHODIMP TelemetryImpl::GetAddonHistogram(const nsACString &id, const nsACString &name, JSContext *cx, JS::MutableHandle<JS::Value> ret) { return TelemetryHistogram::GetAddonHistogram(id, name, cx, ret); } NS_IMETHODIMP TelemetryImpl::UnregisterAddonHistograms(const nsACString &id) { return TelemetryHistogram::UnregisterAddonHistograms(id); } NS_IMETHODIMP TelemetryImpl::SetHistogramRecordingEnabled(const nsACString &id, bool aEnabled) { return TelemetryHistogram::SetHistogramRecordingEnabled(id, aEnabled); } NS_IMETHODIMP TelemetryImpl::GetHistogramSnapshots(JSContext *cx, JS::MutableHandle<JS::Value> ret) { return TelemetryHistogram::CreateHistogramSnapshots(cx, ret, false, false); } NS_IMETHODIMP TelemetryImpl::SnapshotSubsessionHistograms(bool clearSubsession, JSContext *cx, JS::MutableHandle<JS::Value> ret) { #if !defined(MOZ_WIDGET_ANDROID) return TelemetryHistogram::CreateHistogramSnapshots(cx, ret, true, clearSubsession); #else return NS_OK; #endif } NS_IMETHODIMP TelemetryImpl::GetAddonHistogramSnapshots(JSContext *cx, JS::MutableHandle<JS::Value> ret) { return TelemetryHistogram::GetAddonHistogramSnapshots(cx, ret); } NS_IMETHODIMP TelemetryImpl::GetKeyedHistogramSnapshots(JSContext *cx, JS::MutableHandle<JS::Value> ret) { return TelemetryHistogram::GetKeyedHistogramSnapshots(cx, ret); } bool TelemetryImpl::GetSQLStats(JSContext *cx, JS::MutableHandle<JS::Value> ret, bool includePrivateSql) { JS::Rooted<JSObject*> root_obj(cx, JS_NewPlainObject(cx)); if (!root_obj) return false; ret.setObject(*root_obj); MutexAutoLock hashMutex(mHashMutex); // Add info about slow SQL queries on the main thread if (!AddSQLInfo(cx, root_obj, true, includePrivateSql)) return false; // Add info about slow SQL queries on other threads if (!AddSQLInfo(cx, root_obj, false, includePrivateSql)) return false; return true; } NS_IMETHODIMP TelemetryImpl::GetSlowSQL(JSContext *cx, JS::MutableHandle<JS::Value> ret) { if (GetSQLStats(cx, ret, false)) return NS_OK; return NS_ERROR_FAILURE; } NS_IMETHODIMP TelemetryImpl::GetDebugSlowSQL(JSContext *cx, JS::MutableHandle<JS::Value> ret) { bool revealPrivateSql = Preferences::GetBool("toolkit.telemetry.debugSlowSql", false); if (GetSQLStats(cx, ret, revealPrivateSql)) return NS_OK; return NS_ERROR_FAILURE; } NS_IMETHODIMP TelemetryImpl::GetWebrtcStats(JSContext *cx, JS::MutableHandle<JS::Value> ret) { if (mWebrtcTelemetry.GetWebrtcStats(cx, ret)) return NS_OK; return NS_ERROR_FAILURE; } NS_IMETHODIMP TelemetryImpl::GetMaximalNumberOfConcurrentThreads(uint32_t *ret) { *ret = nsThreadManager::get().GetHighestNumberOfThreads(); return NS_OK; } NS_IMETHODIMP TelemetryImpl::GetChromeHangs(JSContext *cx, JS::MutableHandle<JS::Value> ret) { MutexAutoLock hangReportMutex(mHangReportsMutex); const CombinedStacks& stacks = mHangReports.GetStacks(); JS::Rooted<JSObject*> fullReportObj(cx, CreateJSStackObject(cx, stacks)); if (!fullReportObj) { return NS_ERROR_FAILURE; } ret.setObject(*fullReportObj); JS::Rooted<JSObject*> durationArray(cx, JS_NewArrayObject(cx, 0)); JS::Rooted<JSObject*> systemUptimeArray(cx, JS_NewArrayObject(cx, 0)); JS::Rooted<JSObject*> firefoxUptimeArray(cx, JS_NewArrayObject(cx, 0)); JS::Rooted<JSObject*> annotationsArray(cx, JS_NewArrayObject(cx, 0)); if (!durationArray || !systemUptimeArray || !firefoxUptimeArray || !annotationsArray) { return NS_ERROR_FAILURE; } bool ok = JS_DefineProperty(cx, fullReportObj, "durations", durationArray, JSPROP_ENUMERATE); if (!ok) { return NS_ERROR_FAILURE; } ok = JS_DefineProperty(cx, fullReportObj, "systemUptime", systemUptimeArray, JSPROP_ENUMERATE); if (!ok) { return NS_ERROR_FAILURE; } ok = JS_DefineProperty(cx, fullReportObj, "firefoxUptime", firefoxUptimeArray, JSPROP_ENUMERATE); if (!ok) { return NS_ERROR_FAILURE; } ok = JS_DefineProperty(cx, fullReportObj, "annotations", annotationsArray, JSPROP_ENUMERATE); if (!ok) { return NS_ERROR_FAILURE; } const size_t length = stacks.GetStackCount(); for (size_t i = 0; i < length; ++i) { if (!JS_DefineElement(cx, durationArray, i, mHangReports.GetDuration(i), JSPROP_ENUMERATE)) { return NS_ERROR_FAILURE; } if (!JS_DefineElement(cx, systemUptimeArray, i, mHangReports.GetSystemUptime(i), JSPROP_ENUMERATE)) { return NS_ERROR_FAILURE; } if (!JS_DefineElement(cx, firefoxUptimeArray, i, mHangReports.GetFirefoxUptime(i), JSPROP_ENUMERATE)) { return NS_ERROR_FAILURE; } size_t annotationIndex = 0; const nsClassHashtable<nsStringHashKey, HangReports::AnnotationInfo>& annotationInfo = mHangReports.GetAnnotationInfo(); for (auto iter = annotationInfo.ConstIter(); !iter.Done(); iter.Next()) { const HangReports::AnnotationInfo* info = iter.Data(); JS::Rooted<JSObject*> keyValueArray(cx, JS_NewArrayObject(cx, 0)); if (!keyValueArray) { return NS_ERROR_FAILURE; } // Create an array containing all the indices of the chrome hangs relative to this // annotation. JS::Rooted<JS::Value> indicesArray(cx); if (!mozilla::dom::ToJSValue(cx, info->mHangIndices, &indicesArray)) { return NS_ERROR_OUT_OF_MEMORY; } // We're saving the annotation as [[indices], {annotation-data}], so add the indices // array as the first element of that structure. if (!JS_DefineElement(cx, keyValueArray, 0, indicesArray, JSPROP_ENUMERATE)) { return NS_ERROR_FAILURE; } // Create the annotations object... JS::Rooted<JSObject*> jsAnnotation(cx, JS_NewPlainObject(cx)); if (!jsAnnotation) { return NS_ERROR_FAILURE; } UniquePtr<HangAnnotations::Enumerator> annotationsEnum = info->mAnnotations->GetEnumerator(); if (!annotationsEnum) { return NS_ERROR_FAILURE; } // ... fill it with key:value pairs... nsAutoString key; nsAutoString value; while (annotationsEnum->Next(key, value)) { JS::RootedValue jsValue(cx); jsValue.setString(JS_NewUCStringCopyN(cx, value.get(), value.Length())); if (!JS_DefineUCProperty(cx, jsAnnotation, key.get(), key.Length(), jsValue, JSPROP_ENUMERATE)) { return NS_ERROR_FAILURE; } } // ... and append it after the indices array. if (!JS_DefineElement(cx, keyValueArray, 1, jsAnnotation, JSPROP_ENUMERATE)) { return NS_ERROR_FAILURE; } if (!JS_DefineElement(cx, annotationsArray, annotationIndex++, keyValueArray, JSPROP_ENUMERATE)) { return NS_ERROR_FAILURE; } } } return NS_OK; } static JSObject * CreateJSStackObject(JSContext *cx, const CombinedStacks &stacks) { JS::Rooted<JSObject*> ret(cx, JS_NewPlainObject(cx)); if (!ret) { return nullptr; } JS::Rooted<JSObject*> moduleArray(cx, JS_NewArrayObject(cx, 0)); if (!moduleArray) { return nullptr; } bool ok = JS_DefineProperty(cx, ret, "memoryMap", moduleArray, JSPROP_ENUMERATE); if (!ok) { return nullptr; } const size_t moduleCount = stacks.GetModuleCount(); for (size_t moduleIndex = 0; moduleIndex < moduleCount; ++moduleIndex) { // Current module const Telemetry::ProcessedStack::Module& module = stacks.GetModule(moduleIndex); JS::Rooted<JSObject*> moduleInfoArray(cx, JS_NewArrayObject(cx, 0)); if (!moduleInfoArray) { return nullptr; } if (!JS_DefineElement(cx, moduleArray, moduleIndex, moduleInfoArray, JSPROP_ENUMERATE)) { return nullptr; } unsigned index = 0; // Module name JS::Rooted<JSString*> str(cx, JS_NewStringCopyZ(cx, module.mName.c_str())); if (!str) { return nullptr; } if (!JS_DefineElement(cx, moduleInfoArray, index++, str, JSPROP_ENUMERATE)) { return nullptr; } // Module breakpad identifier JS::Rooted<JSString*> id(cx, JS_NewStringCopyZ(cx, module.mBreakpadId.c_str())); if (!id) { return nullptr; } if (!JS_DefineElement(cx, moduleInfoArray, index++, id, JSPROP_ENUMERATE)) { return nullptr; } } JS::Rooted<JSObject*> reportArray(cx, JS_NewArrayObject(cx, 0)); if (!reportArray) { return nullptr; } ok = JS_DefineProperty(cx, ret, "stacks", reportArray, JSPROP_ENUMERATE); if (!ok) { return nullptr; } const size_t length = stacks.GetStackCount(); for (size_t i = 0; i < length; ++i) { // Represent call stack PCs as (module index, offset) pairs. JS::Rooted<JSObject*> pcArray(cx, JS_NewArrayObject(cx, 0)); if (!pcArray) { return nullptr; } if (!JS_DefineElement(cx, reportArray, i, pcArray, JSPROP_ENUMERATE)) { return nullptr; } const CombinedStacks::Stack& stack = stacks.GetStack(i); const uint32_t pcCount = stack.size(); for (size_t pcIndex = 0; pcIndex < pcCount; ++pcIndex) { const Telemetry::ProcessedStack::Frame& frame = stack[pcIndex]; JS::Rooted<JSObject*> framePair(cx, JS_NewArrayObject(cx, 0)); if (!framePair) { return nullptr; } int modIndex = (std::numeric_limits<uint16_t>::max() == frame.mModIndex) ? -1 : frame.mModIndex; if (!JS_DefineElement(cx, framePair, 0, modIndex, JSPROP_ENUMERATE)) { return nullptr; } if (!JS_DefineElement(cx, framePair, 1, static_cast<double>(frame.mOffset), JSPROP_ENUMERATE)) { return nullptr; } if (!JS_DefineElement(cx, pcArray, pcIndex, framePair, JSPROP_ENUMERATE)) { return nullptr; } } } return ret; } static bool IsValidBreakpadId(const std::string &breakpadId) { if (breakpadId.size() < 33) { return false; } for (unsigned i = 0, n = breakpadId.size(); i < n; ++i) { char c = breakpadId[i]; if ((c < '0' || c > '9') && (c < 'A' || c > 'F')) { return false; } } return true; } // Read a stack from the given file name. In case of any error, aStack is // unchanged. static void ReadStack(const char *aFileName, Telemetry::ProcessedStack &aStack) { std::ifstream file(aFileName); size_t numModules; file >> numModules; if (file.fail()) { return; } char newline = file.get(); if (file.fail() || newline != '\n') { return; } Telemetry::ProcessedStack stack; for (size_t i = 0; i < numModules; ++i) { std::string breakpadId; file >> breakpadId; if (file.fail() || !IsValidBreakpadId(breakpadId)) { return; } char space = file.get(); if (file.fail() || space != ' ') { return; } std::string moduleName; getline(file, moduleName); if (file.fail() || moduleName[0] == ' ') { return; } Telemetry::ProcessedStack::Module module = { moduleName, breakpadId }; stack.AddModule(module); } size_t numFrames; file >> numFrames; if (file.fail()) { return; } newline = file.get(); if (file.fail() || newline != '\n') { return; } for (size_t i = 0; i < numFrames; ++i) { uint16_t index; file >> index; uintptr_t offset; file >> std::hex >> offset >> std::dec; if (file.fail()) { return; } Telemetry::ProcessedStack::Frame frame = { offset, index }; stack.AddFrame(frame); } aStack = stack; } static JSObject* CreateJSTimeHistogram(JSContext* cx, const Telemetry::TimeHistogram& time) { /* Create JS representation of TimeHistogram, in the format of Chromium-style histograms. */ JS::RootedObject ret(cx, JS_NewPlainObject(cx)); if (!ret) { return nullptr; } if (!JS_DefineProperty(cx, ret, "min", time.GetBucketMin(0), JSPROP_ENUMERATE) || !JS_DefineProperty(cx, ret, "max", time.GetBucketMax(ArrayLength(time) - 1), JSPROP_ENUMERATE) || !JS_DefineProperty(cx, ret, "histogram_type", nsITelemetry::HISTOGRAM_EXPONENTIAL, JSPROP_ENUMERATE)) { return nullptr; } // TODO: calculate "sum" if (!JS_DefineProperty(cx, ret, "sum", 0, JSPROP_ENUMERATE)) { return nullptr; } JS::RootedObject ranges( cx, JS_NewArrayObject(cx, ArrayLength(time) + 1)); JS::RootedObject counts( cx, JS_NewArrayObject(cx, ArrayLength(time) + 1)); if (!ranges || !counts) { return nullptr; } /* In a Chromium-style histogram, the first bucket is an "under" bucket that represents all values below the histogram's range. */ if (!JS_DefineElement(cx, ranges, 0, time.GetBucketMin(0), JSPROP_ENUMERATE) || !JS_DefineElement(cx, counts, 0, 0, JSPROP_ENUMERATE)) { return nullptr; } for (size_t i = 0; i < ArrayLength(time); i++) { if (!JS_DefineElement(cx, ranges, i + 1, time.GetBucketMax(i), JSPROP_ENUMERATE) || !JS_DefineElement(cx, counts, i + 1, time[i], JSPROP_ENUMERATE)) { return nullptr; } } if (!JS_DefineProperty(cx, ret, "ranges", ranges, JSPROP_ENUMERATE) || !JS_DefineProperty(cx, ret, "counts", counts, JSPROP_ENUMERATE)) { return nullptr; } return ret; } static JSObject* CreateJSHangStack(JSContext* cx, const Telemetry::HangStack& stack) { JS::RootedObject ret(cx, JS_NewArrayObject(cx, stack.length())); if (!ret) { return nullptr; } for (size_t i = 0; i < stack.length(); i++) { JS::RootedString string(cx, JS_NewStringCopyZ(cx, stack[i])); if (!JS_DefineElement(cx, ret, i, string, JSPROP_ENUMERATE)) { return nullptr; } } return ret; } static void CreateJSHangAnnotations(JSContext* cx, const HangAnnotationsVector& annotations, JS::MutableHandleObject returnedObject) { JS::RootedObject annotationsArray(cx, JS_NewArrayObject(cx, 0)); if (!annotationsArray) { returnedObject.set(nullptr); return; } // We keep track of the annotations we reported in this hash set, so we can // discard duplicated ones. nsTHashtable<nsStringHashKey> reportedAnnotations; size_t annotationIndex = 0; for (const HangAnnotationsPtr *i = annotations.begin(), *e = annotations.end(); i != e; ++i) { JS::RootedObject jsAnnotation(cx, JS_NewPlainObject(cx)); if (!jsAnnotation) { continue; } const HangAnnotationsPtr& curAnnotations = *i; // Build a key to index the current annotations in our hash set. nsAutoString annotationsKey; nsresult rv = ComputeAnnotationsKey(curAnnotations, annotationsKey); if (NS_FAILED(rv)) { continue; } // Check if the annotations are in the set. If that's the case, don't double report. if (reportedAnnotations.GetEntry(annotationsKey)) { continue; } // If not, report them. reportedAnnotations.PutEntry(annotationsKey); UniquePtr<HangAnnotations::Enumerator> annotationsEnum = curAnnotations->GetEnumerator(); if (!annotationsEnum) { continue; } nsAutoString key; nsAutoString value; while (annotationsEnum->Next(key, value)) { JS::RootedValue jsValue(cx); jsValue.setString(JS_NewUCStringCopyN(cx, value.get(), value.Length())); if (!JS_DefineUCProperty(cx, jsAnnotation, key.get(), key.Length(), jsValue, JSPROP_ENUMERATE)) { returnedObject.set(nullptr); return; } } if (!JS_SetElement(cx, annotationsArray, annotationIndex, jsAnnotation)) { continue; } ++annotationIndex; } // Return the array using a |MutableHandleObject| to avoid triggering a false // positive rooting issue in the hazard analysis build. returnedObject.set(annotationsArray); } static JSObject* CreateJSHangHistogram(JSContext* cx, const Telemetry::HangHistogram& hang) { JS::RootedObject ret(cx, JS_NewPlainObject(cx)); if (!ret) { return nullptr; } JS::RootedObject stack(cx, CreateJSHangStack(cx, hang.GetStack())); JS::RootedObject time(cx, CreateJSTimeHistogram(cx, hang)); auto& hangAnnotations = hang.GetAnnotations(); JS::RootedObject annotations(cx); CreateJSHangAnnotations(cx, hangAnnotations, &annotations); if (!stack || !time || !annotations || !JS_DefineProperty(cx, ret, "stack", stack, JSPROP_ENUMERATE) || !JS_DefineProperty(cx, ret, "histogram", time, JSPROP_ENUMERATE) || (!hangAnnotations.empty() && // <-- Only define annotations when nonempty !JS_DefineProperty(cx, ret, "annotations", annotations, JSPROP_ENUMERATE))) { return nullptr; } if (!hang.GetNativeStack().empty()) { JS::RootedObject native(cx, CreateJSHangStack(cx, hang.GetNativeStack())); if (!native || !JS_DefineProperty(cx, ret, "nativeStack", native, JSPROP_ENUMERATE)) { return nullptr; } } return ret; } static JSObject* CreateJSThreadHangStats(JSContext* cx, const Telemetry::ThreadHangStats& thread) { JS::RootedObject ret(cx, JS_NewPlainObject(cx)); if (!ret) { return nullptr; } JS::RootedString name(cx, JS_NewStringCopyZ(cx, thread.GetName())); if (!name || !JS_DefineProperty(cx, ret, "name", name, JSPROP_ENUMERATE)) { return nullptr; } JS::RootedObject activity(cx, CreateJSTimeHistogram(cx, thread.mActivity)); if (!activity || !JS_DefineProperty(cx, ret, "activity", activity, JSPROP_ENUMERATE)) { return nullptr; } JS::RootedObject hangs(cx, JS_NewArrayObject(cx, 0)); if (!hangs) { return nullptr; } for (size_t i = 0; i < thread.mHangs.length(); i++) { JS::RootedObject obj(cx, CreateJSHangHistogram(cx, thread.mHangs[i])); if (!JS_DefineElement(cx, hangs, i, obj, JSPROP_ENUMERATE)) { return nullptr; } } if (!JS_DefineProperty(cx, ret, "hangs", hangs, JSPROP_ENUMERATE)) { return nullptr; } return ret; } NS_IMETHODIMP TelemetryImpl::GetThreadHangStats(JSContext* cx, JS::MutableHandle<JS::Value> ret) { JS::RootedObject retObj(cx, JS_NewArrayObject(cx, 0)); if (!retObj) { return NS_ERROR_FAILURE; } size_t threadIndex = 0; if (!BackgroundHangMonitor::IsDisabled()) { /* First add active threads; we need to hold |iter| (and its lock) throughout this method to avoid a race condition where a thread can be recorded twice if the thread is destroyed while this method is running */ BackgroundHangMonitor::ThreadHangStatsIterator iter; for (Telemetry::ThreadHangStats* histogram = iter.GetNext(); histogram; histogram = iter.GetNext()) { JS::RootedObject obj(cx, CreateJSThreadHangStats(cx, *histogram)); if (!JS_DefineElement(cx, retObj, threadIndex++, obj, JSPROP_ENUMERATE)) { return NS_ERROR_FAILURE; } } } // Add saved threads next MutexAutoLock autoLock(mThreadHangStatsMutex); for (size_t i = 0; i < mThreadHangStats.length(); i++) { JS::RootedObject obj(cx, CreateJSThreadHangStats(cx, mThreadHangStats[i])); if (!JS_DefineElement(cx, retObj, threadIndex++, obj, JSPROP_ENUMERATE)) { return NS_ERROR_FAILURE; } } ret.setObject(*retObj); return NS_OK; } void TelemetryImpl::ReadLateWritesStacks(nsIFile* aProfileDir) { nsAutoCString nativePath; nsresult rv = aProfileDir->GetNativePath(nativePath); if (NS_FAILED(rv)) { return; } const char *name = nativePath.get(); PRDir *dir = PR_OpenDir(name); if (!dir) { return; } PRDirEntry *ent; const char *prefix = "Telemetry.LateWriteFinal-"; unsigned int prefixLen = strlen(prefix); while ((ent = PR_ReadDir(dir, PR_SKIP_NONE))) { if (strncmp(prefix, ent->name, prefixLen) != 0) { continue; } nsAutoCString stackNativePath = nativePath; stackNativePath += XPCOM_FILE_PATH_SEPARATOR; stackNativePath += nsDependentCString(ent->name); Telemetry::ProcessedStack stack; ReadStack(stackNativePath.get(), stack); if (stack.GetStackSize() != 0) { mLateWritesStacks.AddStack(stack); } // Delete the file so that we don't report it again on the next run. PR_Delete(stackNativePath.get()); } PR_CloseDir(dir); } NS_IMETHODIMP TelemetryImpl::GetLateWrites(JSContext *cx, JS::MutableHandle<JS::Value> ret) { // The user must call AsyncReadTelemetryData first. We return an empty list // instead of reporting a failure so that the rest of telemetry can uniformly // handle the read not being available yet. // FIXME: we allocate the js object again and again in the getter. We should // figure out a way to cache it. In order to do that we have to call // JS_AddNamedObjectRoot. A natural place to do so is in the TelemetryImpl // constructor, but it is not clear how to get a JSContext in there. // Another option would be to call it in here when we first call // CreateJSStackObject, but we would still need to figure out where to call // JS_RemoveObjectRoot. Would it be ok to never call JS_RemoveObjectRoot // and just set the pointer to nullptr is the telemetry destructor? JSObject *report; if (!mCachedTelemetryData) { CombinedStacks empty; report = CreateJSStackObject(cx, empty); } else { report = CreateJSStackObject(cx, mLateWritesStacks); } if (report == nullptr) { return NS_ERROR_FAILURE; } ret.setObject(*report); return NS_OK; } NS_IMETHODIMP TelemetryImpl::RegisteredHistograms(uint32_t aDataset, uint32_t *aCount, char*** aHistograms) { return TelemetryHistogram::RegisteredHistograms(aDataset, aCount, aHistograms); } NS_IMETHODIMP TelemetryImpl::RegisteredKeyedHistograms(uint32_t aDataset, uint32_t *aCount, char*** aHistograms) { return TelemetryHistogram::RegisteredKeyedHistograms(aDataset, aCount, aHistograms); } NS_IMETHODIMP TelemetryImpl::GetHistogramById(const nsACString &name, JSContext *cx, JS::MutableHandle<JS::Value> ret) { return TelemetryHistogram::GetHistogramById(name, cx, ret); } NS_IMETHODIMP TelemetryImpl::GetKeyedHistogramById(const nsACString &name, JSContext *cx, JS::MutableHandle<JS::Value> ret) { return TelemetryHistogram::GetKeyedHistogramById(name, cx, ret); } /** * Indicates if Telemetry can record base data (FHR data). This is true if the * FHR data reporting service or self-support are enabled. * * In the unlikely event that adding a new base probe is needed, please check the data * collection wiki at https://wiki.mozilla.org/Firefox/Data_Collection and talk to the * Telemetry team. */ NS_IMETHODIMP TelemetryImpl::GetCanRecordBase(bool *ret) { *ret = TelemetryHistogram::CanRecordBase(); return NS_OK; } NS_IMETHODIMP TelemetryImpl::SetCanRecordBase(bool canRecord) { TelemetryHistogram::SetCanRecordBase(canRecord); TelemetryScalar::SetCanRecordBase(canRecord); TelemetryEvent::SetCanRecordBase(canRecord); return NS_OK; } /** * Indicates if Telemetry is allowed to record extended data. Returns false if the user * hasn't opted into "extended Telemetry" on the Release channel, when the user has * explicitly opted out of Telemetry on Nightly/Aurora/Beta or if manually set to false * during tests. * If the returned value is false, gathering of extended telemetry statistics is disabled. */ NS_IMETHODIMP TelemetryImpl::GetCanRecordExtended(bool *ret) { *ret = TelemetryHistogram::CanRecordExtended(); return NS_OK; } NS_IMETHODIMP TelemetryImpl::SetCanRecordExtended(bool canRecord) { TelemetryHistogram::SetCanRecordExtended(canRecord); TelemetryScalar::SetCanRecordExtended(canRecord); TelemetryEvent::SetCanRecordExtended(canRecord); return NS_OK; } NS_IMETHODIMP TelemetryImpl::GetIsOfficialTelemetry(bool *ret) { #if defined(MOZILLA_OFFICIAL) && defined(MOZ_TELEMETRY_REPORTING) && !defined(DEBUG) *ret = true; #else *ret = false; #endif return NS_OK; } already_AddRefed<nsITelemetry> TelemetryImpl::CreateTelemetryInstance() { MOZ_ASSERT(sTelemetry == nullptr, "CreateTelemetryInstance may only be called once, via GetService()"); bool useTelemetry = false; if (XRE_IsParentProcess() || XRE_IsContentProcess() || XRE_IsGPUProcess()) { useTelemetry = true; } // First, initialize the TelemetryHistogram and TelemetryScalar global states. TelemetryHistogram::InitializeGlobalState(useTelemetry, useTelemetry); // Only record scalars from the parent process. TelemetryScalar::InitializeGlobalState(XRE_IsParentProcess(), XRE_IsParentProcess()); // Only record events from the parent process. TelemetryEvent::InitializeGlobalState(XRE_IsParentProcess(), XRE_IsParentProcess()); // Now, create and initialize the Telemetry global state. sTelemetry = new TelemetryImpl(); // AddRef for the local reference NS_ADDREF(sTelemetry); // AddRef for the caller nsCOMPtr<nsITelemetry> ret = sTelemetry; sTelemetry->InitMemoryReporter(); InitHistogramRecordingEnabled(); // requires sTelemetry to exist return ret.forget(); } void TelemetryImpl::ShutdownTelemetry() { // No point in collecting IO beyond this point ClearIOReporting(); NS_IF_RELEASE(sTelemetry); // Lastly, de-initialise the TelemetryHistogram and TelemetryScalar global states, // so as to release any heap storage that would otherwise be kept alive by it. TelemetryHistogram::DeInitializeGlobalState(); TelemetryScalar::DeInitializeGlobalState(); TelemetryEvent::DeInitializeGlobalState(); } void TelemetryImpl::StoreSlowSQL(const nsACString &sql, uint32_t delay, SanitizedState state) { AutoHashtable<SlowSQLEntryType>* slowSQLMap = nullptr; if (state == Sanitized) slowSQLMap = &(sTelemetry->mSanitizedSQL); else slowSQLMap = &(sTelemetry->mPrivateSQL); MutexAutoLock hashMutex(sTelemetry->mHashMutex); SlowSQLEntryType *entry = slowSQLMap->GetEntry(sql); if (!entry) { entry = slowSQLMap->PutEntry(sql); if (MOZ_UNLIKELY(!entry)) return; entry->mData.mainThread.hitCount = 0; entry->mData.mainThread.totalTime = 0; entry->mData.otherThreads.hitCount = 0; entry->mData.otherThreads.totalTime = 0; } if (NS_IsMainThread()) { entry->mData.mainThread.hitCount++; entry->mData.mainThread.totalTime += delay; } else { entry->mData.otherThreads.hitCount++; entry->mData.otherThreads.totalTime += delay; } } /** * This method replaces string literals in SQL strings with the word :private * * States used in this state machine: * * NORMAL: * - This is the active state when not iterating over a string literal or * comment * * SINGLE_QUOTE: * - Defined here: http://www.sqlite.org/lang_expr.html * - This state represents iterating over a string literal opened with * a single quote. * - A single quote within the string can be encoded by putting 2 single quotes * in a row, e.g. 'This literal contains an escaped quote ''' * - Any double quotes found within a single-quoted literal are ignored * - This state covers BLOB literals, e.g. X'ABC123' * - The string literal and the enclosing quotes will be replaced with * the text :private * * DOUBLE_QUOTE: * - Same rules as the SINGLE_QUOTE state. * - According to http://www.sqlite.org/lang_keywords.html, * SQLite interprets text in double quotes as an identifier unless it's used in * a context where it cannot be resolved to an identifier and a string literal * is allowed. This method removes text in double-quotes for safety. * * DASH_COMMENT: * - http://www.sqlite.org/lang_comment.html * - A dash comment starts with two dashes in a row, * e.g. DROP TABLE foo -- a comment * - Any text following two dashes in a row is interpreted as a comment until * end of input or a newline character * - Any quotes found within the comment are ignored and no replacements made * * C_STYLE_COMMENT: * - http://www.sqlite.org/lang_comment.html * - A C-style comment starts with a forward slash and an asterisk, and ends * with an asterisk and a forward slash * - Any text following comment start is interpreted as a comment up to end of * input or comment end * - Any quotes found within the comment are ignored and no replacements made */ nsCString TelemetryImpl::SanitizeSQL(const nsACString &sql) { nsCString output; int length = sql.Length(); typedef enum { NORMAL, SINGLE_QUOTE, DOUBLE_QUOTE, DASH_COMMENT, C_STYLE_COMMENT, } State; State state = NORMAL; int fragmentStart = 0; for (int i = 0; i < length; i++) { char character = sql[i]; char nextCharacter = (i + 1 < length) ? sql[i + 1] : '\0'; switch (character) { case '\'': case '"': if (state == NORMAL) { state = (character == '\'') ? SINGLE_QUOTE : DOUBLE_QUOTE; output += nsDependentCSubstring(sql, fragmentStart, i - fragmentStart); output += ":private"; fragmentStart = -1; } else if ((state == SINGLE_QUOTE && character == '\'') || (state == DOUBLE_QUOTE && character == '"')) { if (nextCharacter == character) { // Two consecutive quotes within a string literal are a single escaped quote i++; } else { state = NORMAL; fragmentStart = i + 1; } } break; case '-': if (state == NORMAL) { if (nextCharacter == '-') { state = DASH_COMMENT; i++; } } break; case '\n': if (state == DASH_COMMENT) { state = NORMAL; } break; case '/': if (state == NORMAL) { if (nextCharacter == '*') { state = C_STYLE_COMMENT; i++; } } break; case '*': if (state == C_STYLE_COMMENT) { if (nextCharacter == '/') { state = NORMAL; } } break; default: continue; } } if ((fragmentStart >= 0) && fragmentStart < length) output += nsDependentCSubstring(sql, fragmentStart, length - fragmentStart); return output; } // A whitelist mechanism to prevent Telemetry reporting on Addon & Thunderbird // DBs. struct TrackedDBEntry { const char* mName; const uint32_t mNameLength; // This struct isn't meant to be used beyond the static arrays below. constexpr TrackedDBEntry(const char* aName, uint32_t aNameLength) : mName(aName) , mNameLength(aNameLength) { } TrackedDBEntry() = delete; TrackedDBEntry(TrackedDBEntry&) = delete; }; #define TRACKEDDB_ENTRY(_name) { _name, (sizeof(_name) - 1) } // A whitelist of database names. If the database name exactly matches one of // these then its SQL statements will always be recorded. static constexpr TrackedDBEntry kTrackedDBs[] = { // IndexedDB for about:home, see aboutHome.js TRACKEDDB_ENTRY("818200132aebmoouht.sqlite"), TRACKEDDB_ENTRY("addons.sqlite"), TRACKEDDB_ENTRY("content-prefs.sqlite"), TRACKEDDB_ENTRY("cookies.sqlite"), TRACKEDDB_ENTRY("downloads.sqlite"), TRACKEDDB_ENTRY("extensions.sqlite"), TRACKEDDB_ENTRY("formhistory.sqlite"), TRACKEDDB_ENTRY("index.sqlite"), TRACKEDDB_ENTRY("netpredictions.sqlite"), TRACKEDDB_ENTRY("permissions.sqlite"), TRACKEDDB_ENTRY("places.sqlite"), TRACKEDDB_ENTRY("reading-list.sqlite"), TRACKEDDB_ENTRY("search.sqlite"), TRACKEDDB_ENTRY("signons.sqlite"), TRACKEDDB_ENTRY("urlclassifier3.sqlite"), TRACKEDDB_ENTRY("webappsstore.sqlite") }; // A whitelist of database name prefixes. If the database name begins with // one of these prefixes then its SQL statements will always be recorded. static const TrackedDBEntry kTrackedDBPrefixes[] = { TRACKEDDB_ENTRY("indexedDB-") }; #undef TRACKEDDB_ENTRY // Slow SQL statements will be automatically // trimmed to kMaxSlowStatementLength characters. // This limit doesn't include the ellipsis and DB name, // that are appended at the end of the stored statement. const uint32_t kMaxSlowStatementLength = 1000; void TelemetryImpl::RecordSlowStatement(const nsACString &sql, const nsACString &dbName, uint32_t delay) { MOZ_ASSERT(!sql.IsEmpty()); MOZ_ASSERT(!dbName.IsEmpty()); if (!sTelemetry || !TelemetryHistogram::CanRecordExtended()) return; bool recordStatement = false; for (const TrackedDBEntry& nameEntry : kTrackedDBs) { MOZ_ASSERT(nameEntry.mNameLength); const nsDependentCString name(nameEntry.mName, nameEntry.mNameLength); if (dbName == name) { recordStatement = true; break; } } if (!recordStatement) { for (const TrackedDBEntry& prefixEntry : kTrackedDBPrefixes) { MOZ_ASSERT(prefixEntry.mNameLength); const nsDependentCString prefix(prefixEntry.mName, prefixEntry.mNameLength); if (StringBeginsWith(dbName, prefix)) { recordStatement = true; break; } } } if (recordStatement) { nsAutoCString sanitizedSQL(SanitizeSQL(sql)); if (sanitizedSQL.Length() > kMaxSlowStatementLength) { sanitizedSQL.SetLength(kMaxSlowStatementLength); sanitizedSQL += "..."; } sanitizedSQL.AppendPrintf(" /* %s */", nsPromiseFlatCString(dbName).get()); StoreSlowSQL(sanitizedSQL, delay, Sanitized); } else { // Report aggregate DB-level statistics for addon DBs nsAutoCString aggregate; aggregate.AppendPrintf("Untracked SQL for %s", nsPromiseFlatCString(dbName).get()); StoreSlowSQL(aggregate, delay, Sanitized); } nsAutoCString fullSQL; fullSQL.AppendPrintf("%s /* %s */", nsPromiseFlatCString(sql).get(), nsPromiseFlatCString(dbName).get()); StoreSlowSQL(fullSQL, delay, Unsanitized); } void TelemetryImpl::RecordIceCandidates(const uint32_t iceCandidateBitmask, const bool success) { if (!sTelemetry || !TelemetryHistogram::CanRecordExtended()) return; sTelemetry->mWebrtcTelemetry.RecordIceCandidateMask(iceCandidateBitmask, success); } void TelemetryImpl::RecordThreadHangStats(Telemetry::ThreadHangStats& aStats) { if (!sTelemetry || !TelemetryHistogram::CanRecordExtended()) return; MutexAutoLock autoLock(sTelemetry->mThreadHangStatsMutex); // Ignore OOM. mozilla::Unused << sTelemetry->mThreadHangStats.append(Move(aStats)); } NS_IMPL_ISUPPORTS(TelemetryImpl, nsITelemetry, nsIMemoryReporter) NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsITelemetry, TelemetryImpl::CreateTelemetryInstance) #define NS_TELEMETRY_CID \ {0xaea477f2, 0xb3a2, 0x469c, {0xaa, 0x29, 0x0a, 0x82, 0xd1, 0x32, 0xb8, 0x29}} NS_DEFINE_NAMED_CID(NS_TELEMETRY_CID); const Module::CIDEntry kTelemetryCIDs[] = { { &kNS_TELEMETRY_CID, false, nullptr, nsITelemetryConstructor, Module::ALLOW_IN_GPU_PROCESS }, { nullptr } }; const Module::ContractIDEntry kTelemetryContracts[] = { { "@mozilla.org/base/telemetry;1", &kNS_TELEMETRY_CID, Module::ALLOW_IN_GPU_PROCESS }, { nullptr } }; const Module kTelemetryModule = { Module::kVersion, kTelemetryCIDs, kTelemetryContracts, nullptr, nullptr, nullptr, TelemetryImpl::ShutdownTelemetry, Module::ALLOW_IN_GPU_PROCESS }; NS_IMETHODIMP TelemetryImpl::GetFileIOReports(JSContext *cx, JS::MutableHandleValue ret) { if (sTelemetryIOObserver) { JS::Rooted<JSObject*> obj(cx, JS_NewPlainObject(cx)); if (!obj) { return NS_ERROR_FAILURE; } if (!sTelemetryIOObserver->ReflectIntoJS(cx, obj)) { return NS_ERROR_FAILURE; } ret.setObject(*obj); return NS_OK; } ret.setNull(); return NS_OK; } NS_IMETHODIMP TelemetryImpl::MsSinceProcessStart(double* aResult) { return Telemetry::Common::MsSinceProcessStart(aResult); } // Telemetry Scalars IDL Implementation NS_IMETHODIMP TelemetryImpl::ScalarAdd(const nsACString& aName, JS::HandleValue aVal, JSContext* aCx) { return TelemetryScalar::Add(aName, aVal, aCx); } NS_IMETHODIMP TelemetryImpl::ScalarSet(const nsACString& aName, JS::HandleValue aVal, JSContext* aCx) { return TelemetryScalar::Set(aName, aVal, aCx); } NS_IMETHODIMP TelemetryImpl::ScalarSetMaximum(const nsACString& aName, JS::HandleValue aVal, JSContext* aCx) { return TelemetryScalar::SetMaximum(aName, aVal, aCx); } NS_IMETHODIMP TelemetryImpl::SnapshotScalars(unsigned int aDataset, bool aClearScalars, JSContext* aCx, uint8_t optional_argc, JS::MutableHandleValue aResult) { return TelemetryScalar::CreateSnapshots(aDataset, aClearScalars, aCx, optional_argc, aResult); } NS_IMETHODIMP TelemetryImpl::KeyedScalarAdd(const nsACString& aName, const nsAString& aKey, JS::HandleValue aVal, JSContext* aCx) { return TelemetryScalar::Add(aName, aKey, aVal, aCx); } NS_IMETHODIMP TelemetryImpl::KeyedScalarSet(const nsACString& aName, const nsAString& aKey, JS::HandleValue aVal, JSContext* aCx) { return TelemetryScalar::Set(aName, aKey, aVal, aCx); } NS_IMETHODIMP TelemetryImpl::KeyedScalarSetMaximum(const nsACString& aName, const nsAString& aKey, JS::HandleValue aVal, JSContext* aCx) { return TelemetryScalar::SetMaximum(aName, aKey, aVal, aCx); } NS_IMETHODIMP TelemetryImpl::SnapshotKeyedScalars(unsigned int aDataset, bool aClearScalars, JSContext* aCx, uint8_t optional_argc, JS::MutableHandleValue aResult) { return TelemetryScalar::CreateKeyedSnapshots(aDataset, aClearScalars, aCx, optional_argc, aResult); } NS_IMETHODIMP TelemetryImpl::ClearScalars() { TelemetryScalar::ClearScalars(); return NS_OK; } // Telemetry Event IDL implementation. NS_IMETHODIMP TelemetryImpl::RecordEvent(const nsACString & aCategory, const nsACString & aMethod, const nsACString & aObject, JS::HandleValue aValue, JS::HandleValue aExtra, JSContext* aCx, uint8_t optional_argc) { return TelemetryEvent::RecordEvent(aCategory, aMethod, aObject, aValue, aExtra, aCx, optional_argc); } NS_IMETHODIMP TelemetryImpl::SnapshotBuiltinEvents(uint32_t aDataset, bool aClear, JSContext* aCx, uint8_t optional_argc, JS::MutableHandleValue aResult) { return TelemetryEvent::CreateSnapshots(aDataset, aClear, aCx, optional_argc, aResult); } NS_IMETHODIMP TelemetryImpl::ClearEvents() { TelemetryEvent::ClearEvents(); return NS_OK; } NS_IMETHODIMP TelemetryImpl::FlushBatchedChildTelemetry() { TelemetryHistogram::IPCTimerFired(nullptr, nullptr); return NS_OK; } size_t TelemetryImpl::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) { size_t n = aMallocSizeOf(this); // Ignore the hashtables in mAddonMap; they are not significant. n += TelemetryHistogram::GetMapShallowSizesOfExcludingThis(aMallocSizeOf); n += TelemetryScalar::GetMapShallowSizesOfExcludingThis(aMallocSizeOf); n += mWebrtcTelemetry.SizeOfExcludingThis(aMallocSizeOf); { // Scope for mHashMutex lock MutexAutoLock lock(mHashMutex); n += mPrivateSQL.SizeOfExcludingThis(aMallocSizeOf); n += mSanitizedSQL.SizeOfExcludingThis(aMallocSizeOf); } { // Scope for mHangReportsMutex lock MutexAutoLock lock(mHangReportsMutex); n += mHangReports.SizeOfExcludingThis(aMallocSizeOf); } { // Scope for mThreadHangStatsMutex lock MutexAutoLock lock(mThreadHangStatsMutex); n += mThreadHangStats.sizeOfExcludingThis(aMallocSizeOf); } // It's a bit gross that we measure this other stuff that lives outside of // TelemetryImpl... oh well. if (sTelemetryIOObserver) { n += sTelemetryIOObserver->SizeOfIncludingThis(aMallocSizeOf); } n += TelemetryHistogram::GetHistogramSizesofIncludingThis(aMallocSizeOf); n += TelemetryScalar::GetScalarSizesOfIncludingThis(aMallocSizeOf); n += TelemetryEvent::SizeOfIncludingThis(aMallocSizeOf); return n; } struct StackFrame { uintptr_t mPC; // The program counter at this position in the call stack. uint16_t mIndex; // The number of this frame in the call stack. uint16_t mModIndex; // The index of module that has this program counter. }; } // namespace //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// // // EXTERNALLY VISIBLE FUNCTIONS in no name space // These are NOT listed in Telemetry.h NSMODULE_DEFN(nsTelemetryModule) = &kTelemetryModule; /** * The XRE_TelemetryAdd function is to be used by embedding applications * that can't use mozilla::Telemetry::Accumulate() directly. */ void XRE_TelemetryAccumulate(int aID, uint32_t aSample) { mozilla::Telemetry::Accumulate((mozilla::Telemetry::ID) aID, aSample); } //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// // // EXTERNALLY VISIBLE FUNCTIONS in mozilla:: // These are NOT listed in Telemetry.h namespace mozilla { void RecordShutdownStartTimeStamp() { #ifdef DEBUG // FIXME: this function should only be called once, since it should be called // at the earliest point we *know* we are shutting down. Unfortunately // this assert has been firing. Given that if we are called multiple times // we just keep the last timestamp, the assert is commented for now. static bool recorded = false; // MOZ_ASSERT(!recorded); (void)recorded; // Silence unused-var warnings (remove when assert re-enabled) recorded = true; #endif if (!Telemetry::CanRecordExtended()) return; gRecordedShutdownStartTime = TimeStamp::Now(); GetShutdownTimeFileName(); } void RecordShutdownEndTimeStamp() { if (!gRecordedShutdownTimeFileName || gAlreadyFreedShutdownTimeFileName) return; nsCString name(gRecordedShutdownTimeFileName); PL_strfree(gRecordedShutdownTimeFileName); gRecordedShutdownTimeFileName = nullptr; gAlreadyFreedShutdownTimeFileName = true; if (gRecordedShutdownStartTime.IsNull()) { // If |CanRecordExtended()| is true before |AsyncFetchTelemetryData| is called and // then disabled before shutdown, |RecordShutdownStartTimeStamp| will bail out and // we will end up with a null |gRecordedShutdownStartTime| here. This can happen // during tests. return; } nsCString tmpName = name; tmpName += ".tmp"; FILE *f = fopen(tmpName.get(), "w"); if (!f) return; // On a normal release build this should be called just before // calling _exit, but on a debug build or when the user forces a full // shutdown this is called as late as possible, so we have to // white list this write as write poisoning will be enabled. MozillaRegisterDebugFILE(f); TimeStamp now = TimeStamp::Now(); MOZ_ASSERT(now >= gRecordedShutdownStartTime); TimeDuration diff = now - gRecordedShutdownStartTime; uint32_t diff2 = diff.ToMilliseconds(); int written = fprintf(f, "%d\n", diff2); MozillaUnRegisterDebugFILE(f); int rv = fclose(f); if (written < 0 || rv != 0) { PR_Delete(tmpName.get()); return; } PR_Delete(name.get()); PR_Rename(tmpName.get(), name.get()); } } // namespace mozilla //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// // // EXTERNALLY VISIBLE FUNCTIONS in mozilla::Telemetry:: // These are NOT listed in Telemetry.h namespace mozilla { namespace Telemetry { ProcessedStack::ProcessedStack() { } size_t ProcessedStack::GetStackSize() const { return mStack.size(); } size_t ProcessedStack::GetNumModules() const { return mModules.size(); } bool ProcessedStack::Module::operator==(const Module& aOther) const { return mName == aOther.mName && mBreakpadId == aOther.mBreakpadId; } const ProcessedStack::Frame &ProcessedStack::GetFrame(unsigned aIndex) const { MOZ_ASSERT(aIndex < mStack.size()); return mStack[aIndex]; } void ProcessedStack::AddFrame(const Frame &aFrame) { mStack.push_back(aFrame); } const ProcessedStack::Module &ProcessedStack::GetModule(unsigned aIndex) const { MOZ_ASSERT(aIndex < mModules.size()); return mModules[aIndex]; } void ProcessedStack::AddModule(const Module &aModule) { mModules.push_back(aModule); } void ProcessedStack::Clear() { mModules.clear(); mStack.clear(); } ProcessedStack GetStackAndModules(const std::vector<uintptr_t>& aPCs) { std::vector<StackFrame> rawStack; auto stackEnd = aPCs.begin() + std::min(aPCs.size(), kMaxChromeStackDepth); for (auto i = aPCs.begin(); i != stackEnd; ++i) { uintptr_t aPC = *i; StackFrame Frame = {aPC, static_cast<uint16_t>(rawStack.size()), std::numeric_limits<uint16_t>::max()}; rawStack.push_back(Frame); } // Copy the information to the return value. ProcessedStack Ret; for (std::vector<StackFrame>::iterator i = rawStack.begin(), e = rawStack.end(); i != e; ++i) { const StackFrame &rawFrame = *i; mozilla::Telemetry::ProcessedStack::Frame frame = { rawFrame.mPC, rawFrame.mModIndex }; Ret.AddFrame(frame); } return Ret; } void TimeHistogram::Add(PRIntervalTime aTime) { uint32_t timeMs = PR_IntervalToMilliseconds(aTime); size_t index = mozilla::FloorLog2(timeMs); operator[](index)++; } const char* HangStack::InfallibleAppendViaBuffer(const char* aText, size_t aLength) { MOZ_ASSERT(this->canAppendWithoutRealloc(1)); // Include null-terminator in length count. MOZ_ASSERT(mBuffer.canAppendWithoutRealloc(aLength + 1)); const char* const entry = mBuffer.end(); mBuffer.infallibleAppend(aText, aLength); mBuffer.infallibleAppend('\0'); // Explicitly append null-terminator this->infallibleAppend(entry); return entry; } const char* HangStack::AppendViaBuffer(const char* aText, size_t aLength) { if (!this->reserve(this->length() + 1)) { return nullptr; } // Keep track of the previous buffer in case we need to adjust pointers later. const char* const prevStart = mBuffer.begin(); const char* const prevEnd = mBuffer.end(); // Include null-terminator in length count. if (!mBuffer.reserve(mBuffer.length() + aLength + 1)) { return nullptr; } if (prevStart != mBuffer.begin()) { // The buffer has moved; we have to adjust pointers in the stack. for (const char** entry = this->begin(); entry != this->end(); entry++) { if (*entry >= prevStart && *entry < prevEnd) { // Move from old buffer to new buffer. *entry += mBuffer.begin() - prevStart; } } } return InfallibleAppendViaBuffer(aText, aLength); } uint32_t HangHistogram::GetHash(const HangStack& aStack) { uint32_t hash = 0; for (const char* const* label = aStack.begin(); label != aStack.end(); label++) { /* If the string is within our buffer, we need to hash its content. Otherwise, the string is statically allocated, and we only need to hash the pointer instead of the content. */ if (aStack.IsInBuffer(*label)) { hash = AddToHash(hash, HashString(*label)); } else { hash = AddToHash(hash, *label); } } return hash; } bool HangHistogram::operator==(const HangHistogram& aOther) const { if (mHash != aOther.mHash) { return false; } if (mStack.length() != aOther.mStack.length()) { return false; } return mStack == aOther.mStack; } } // namespace Telemetry } // namespace mozilla //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// // // EXTERNALLY VISIBLE FUNCTIONS in mozilla::Telemetry:: // These are listed in Telemetry.h namespace mozilla { namespace Telemetry { // The external API for controlling recording state void SetHistogramRecordingEnabled(ID aID, bool aEnabled) { TelemetryHistogram::SetHistogramRecordingEnabled(aID, aEnabled); } void Accumulate(ID aHistogram, uint32_t aSample) { TelemetryHistogram::Accumulate(aHistogram, aSample); } void Accumulate(ID aID, const nsCString& aKey, uint32_t aSample) { TelemetryHistogram::Accumulate(aID, aKey, aSample); } void Accumulate(const char* name, uint32_t sample) { TelemetryHistogram::Accumulate(name, sample); } void Accumulate(const char *name, const nsCString& key, uint32_t sample) { TelemetryHistogram::Accumulate(name, key, sample); } void AccumulateCategorical(ID id, const nsCString& label) { TelemetryHistogram::AccumulateCategorical(id, label); } void AccumulateTimeDelta(ID aHistogram, TimeStamp start, TimeStamp end) { Accumulate(aHistogram, static_cast<uint32_t>((end - start).ToMilliseconds())); } void AccumulateChild(GeckoProcessType aProcessType, const nsTArray<Accumulation>& aAccumulations) { TelemetryHistogram::AccumulateChild(aProcessType, aAccumulations); } void AccumulateChildKeyed(GeckoProcessType aProcessType, const nsTArray<KeyedAccumulation>& aAccumulations) { TelemetryHistogram::AccumulateChildKeyed(aProcessType, aAccumulations); } const char* GetHistogramName(ID id) { return TelemetryHistogram::GetHistogramName(id); } bool CanRecordBase() { return TelemetryHistogram::CanRecordBase(); } bool CanRecordExtended() { return TelemetryHistogram::CanRecordExtended(); } void RecordSlowSQLStatement(const nsACString &statement, const nsACString &dbName, uint32_t delay) { TelemetryImpl::RecordSlowStatement(statement, dbName, delay); } void RecordWebrtcIceCandidates(const uint32_t iceCandidateBitmask, const bool success) { TelemetryImpl::RecordIceCandidates(iceCandidateBitmask, success); } void Init() { // Make the service manager hold a long-lived reference to the service nsCOMPtr<nsITelemetry> telemetryService = do_GetService("@mozilla.org/base/telemetry;1"); MOZ_ASSERT(telemetryService); } void RecordThreadHangStats(ThreadHangStats& aStats) { TelemetryImpl::RecordThreadHangStats(aStats); } void WriteFailedProfileLock(nsIFile* aProfileDir) { nsCOMPtr<nsIFile> file; nsresult rv = GetFailedProfileLockFile(getter_AddRefs(file), aProfileDir); NS_ENSURE_SUCCESS_VOID(rv); int64_t fileSize = 0; rv = file->GetFileSize(&fileSize); // It's expected that the file might not exist yet if (NS_FAILED(rv) && rv != NS_ERROR_FILE_NOT_FOUND) { return; } nsCOMPtr<nsIFileStream> fileStream; rv = NS_NewLocalFileStream(getter_AddRefs(fileStream), file, PR_RDWR | PR_CREATE_FILE, 0640); NS_ENSURE_SUCCESS_VOID(rv); NS_ENSURE_TRUE_VOID(fileSize <= kMaxFailedProfileLockFileSize); unsigned int failedLockCount = 0; if (fileSize > 0) { nsCOMPtr<nsIInputStream> inStream = do_QueryInterface(fileStream); NS_ENSURE_TRUE_VOID(inStream); if (!GetFailedLockCount(inStream, fileSize, failedLockCount)) { failedLockCount = 0; } } ++failedLockCount; nsAutoCString bufStr; bufStr.AppendInt(static_cast<int>(failedLockCount)); nsCOMPtr<nsISeekableStream> seekStream = do_QueryInterface(fileStream); NS_ENSURE_TRUE_VOID(seekStream); // If we read in an existing failed lock count, we need to reset the file ptr if (fileSize > 0) { rv = seekStream->Seek(nsISeekableStream::NS_SEEK_SET, 0); NS_ENSURE_SUCCESS_VOID(rv); } nsCOMPtr<nsIOutputStream> outStream = do_QueryInterface(fileStream); uint32_t bytesLeft = bufStr.Length(); const char* bytes = bufStr.get(); do { uint32_t written = 0; rv = outStream->Write(bytes, bytesLeft, &written); if (NS_FAILED(rv)) { break; } bytes += written; bytesLeft -= written; } while (bytesLeft > 0); seekStream->SetEOF(); } void InitIOReporting(nsIFile* aXreDir) { // Never initialize twice if (sTelemetryIOObserver) { return; } sTelemetryIOObserver = new TelemetryIOInterposeObserver(aXreDir); IOInterposer::Register(IOInterposeObserver::OpAllWithStaging, sTelemetryIOObserver); } void SetProfileDir(nsIFile* aProfD) { if (!sTelemetryIOObserver || !aProfD) { return; } nsAutoString profDirPath; nsresult rv = aProfD->GetPath(profDirPath); if (NS_FAILED(rv)) { return; } sTelemetryIOObserver->AddPath(profDirPath, NS_LITERAL_STRING("{profile}")); } void CreateStatisticsRecorder() { TelemetryHistogram::CreateStatisticsRecorder(); } void DestroyStatisticsRecorder() { TelemetryHistogram::DestroyStatisticsRecorder(); } // Scalar API C++ Endpoints void ScalarAdd(mozilla::Telemetry::ScalarID aId, uint32_t aVal) { TelemetryScalar::Add(aId, aVal); } void ScalarSet(mozilla::Telemetry::ScalarID aId, uint32_t aVal) { TelemetryScalar::Set(aId, aVal); } void ScalarSet(mozilla::Telemetry::ScalarID aId, bool aVal) { TelemetryScalar::Set(aId, aVal); } void ScalarSet(mozilla::Telemetry::ScalarID aId, const nsAString& aVal) { TelemetryScalar::Set(aId, aVal); } void ScalarSetMaximum(mozilla::Telemetry::ScalarID aId, uint32_t aVal) { TelemetryScalar::SetMaximum(aId, aVal); } void ScalarAdd(mozilla::Telemetry::ScalarID aId, const nsAString& aKey, uint32_t aVal) { TelemetryScalar::Add(aId, aKey, aVal); } void ScalarSet(mozilla::Telemetry::ScalarID aId, const nsAString& aKey, uint32_t aVal) { TelemetryScalar::Set(aId, aKey, aVal); } void ScalarSet(mozilla::Telemetry::ScalarID aId, const nsAString& aKey, bool aVal) { TelemetryScalar::Set(aId, aKey, aVal); } void ScalarSetMaximum(mozilla::Telemetry::ScalarID aId, const nsAString& aKey, uint32_t aVal) { TelemetryScalar::SetMaximum(aId, aKey, aVal); } } // namespace Telemetry } // namespace mozilla