| // Copyright 2014 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // This file defines a service that collects information about the user |
| // experience in order to help improve future versions of the app. |
| |
| #ifndef COMPONENTS_METRICS_METRICS_SERVICE_H_ |
| #define COMPONENTS_METRICS_METRICS_SERVICE_H_ |
| |
| #include <stdint.h> |
| |
| #include <map> |
| #include <memory> |
| #include <string> |
| |
| #include "base/callback_list.h" |
| #include "base/functional/bind.h" |
| #include "base/functional/callback_forward.h" |
| #include "base/gtest_prod_util.h" |
| #include "base/memory/raw_ptr.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/metrics/field_trial.h" |
| #include "base/metrics/histogram_flattener.h" |
| #include "base/metrics/histogram_snapshot_manager.h" |
| #include "base/metrics/statistics_recorder.h" |
| #include "base/metrics/user_metrics.h" |
| #include "base/observer_list.h" |
| #include "base/scoped_observation.h" |
| #include "base/sequence_checker.h" |
| #include "base/time/time.h" |
| #include "build/build_config.h" |
| #include "build/chromeos_buildflags.h" |
| #include "components/metrics/delegating_provider.h" |
| #include "components/metrics/metrics_log.h" |
| #include "components/metrics/metrics_log_store.h" |
| #include "components/metrics/metrics_logs_event_manager.h" |
| #include "components/metrics/metrics_provider.h" |
| #include "components/metrics/metrics_reporting_service.h" |
| |
| class PrefService; |
| class PrefRegistrySimple; |
| FORWARD_DECLARE_TEST(ChromeMetricsServiceClientTest, |
| TestRegisterMetricsServiceProviders); |
| FORWARD_DECLARE_TEST(IOSChromeMetricsServiceClientTest, |
| TestRegisterMetricsServiceProviders); |
| |
| namespace base { |
| class PrefService; |
| } // namespace base |
| |
| namespace variations { |
| class SyntheticTrialRegistry; |
| } |
| |
| namespace metrics { |
| |
| class MetricsRotationScheduler; |
| class MetricsServiceClient; |
| class MetricsServiceObserver; |
| class MetricsStateManager; |
| |
| // See metrics_service.cc for a detailed description. |
| class MetricsService { |
| public: |
| // Creates the MetricsService with the given |state_manager|, |client|, and |
| // |local_state|. Does not take ownership of the paramaters; instead stores |
| // a weak pointer to each. Caller should ensure that the parameters are valid |
| // for the lifetime of this class. |
| MetricsService(MetricsStateManager* state_manager, |
| MetricsServiceClient* client, |
| PrefService* local_state); |
| |
| MetricsService(const MetricsService&) = delete; |
| MetricsService& operator=(const MetricsService&) = delete; |
| |
| virtual ~MetricsService(); |
| |
| // Initializes metrics recording state. Updates various bookkeeping values in |
| // prefs and sets up the scheduler. This is a separate function rather than |
| // being done by the constructor so that field trials could be created before |
| // this is run. |
| void InitializeMetricsRecordingState(); |
| |
| // Starts the metrics system, turning on recording and uploading of metrics. |
| // Should be called when starting up with metrics enabled, or when metrics |
| // are turned on. |
| void Start(); |
| |
| // Starts the metrics system in a special test-only mode. Metrics won't ever |
| // be uploaded or persisted in this mode, but metrics will be recorded in |
| // memory. |
| void StartRecordingForTests(); |
| |
| // Starts updating the "last live" browser timestamp. |
| void StartUpdatingLastLiveTimestamp(); |
| |
| // Shuts down the metrics system. Should be called at shutdown, or if metrics |
| // are turned off. |
| void Stop(); |
| |
| // Enable/disable transmission of accumulated logs and crash reports (dumps). |
| // Calling Start() automatically enables reporting, but sending is |
| // asyncronous so this can be called immediately after Start() to prevent |
| // any uploading. |
| void EnableReporting(); |
| void DisableReporting(); |
| |
| // Returns the client ID for this client, or the empty string if metrics |
| // recording is not currently running. |
| std::string GetClientId() const; |
| |
| // Get the low entropy source values. |
| int GetLowEntropySource(); |
| int GetOldLowEntropySource(); |
| int GetPseudoLowEntropySource(); |
| |
| // Set an external provided id for the metrics service. This method can be |
| // set by a caller which wants to explicitly control the *next* id used by the |
| // metrics service. Note that setting the external client id will *not* change |
| // the current metrics client id. In order to change the current client id, |
| // callers should call ResetClientId to change the current client id to the |
| // provided id. |
| void SetExternalClientId(const std::string& id); |
| |
| // Returns the date at which the current metrics client ID was created as |
| // an int64_t containing seconds since the epoch. |
| int64_t GetMetricsReportingEnabledDate(); |
| |
| // Returns true if the last session exited cleanly. |
| bool WasLastShutdownClean() const; |
| |
| // Registers local state prefs used by this class. |
| static void RegisterPrefs(PrefRegistrySimple* registry); |
| |
| // This should be called when the application is not idle, i.e. the user seems |
| // to be interacting with the application. |
| void OnApplicationNotIdle(); |
| |
| #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_IOS) |
| // Called when the application is going into background mode. |
| // If |keep_recording_in_background| is true, UMA is still recorded and |
| // reported while in the background. |
| void OnAppEnterBackground(bool keep_recording_in_background = false); |
| |
| // Called when the application is coming out of background mode. |
| void OnAppEnterForeground(bool force_open_new_log = false); |
| #endif // BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_IOS) |
| |
| // Called when a document first starts loading. |
| void OnPageLoadStarted(); |
| |
| // Signals that the browser is shutting down cleanly. Intended to be called |
| // during shutdown after critical shutdown tasks have completed. |
| void LogCleanShutdown(); |
| |
| bool recording_active() const; |
| bool reporting_active() const; |
| bool has_unsent_logs() const; |
| |
| bool IsMetricsReportingEnabled() const; |
| |
| // Register the specified |provider| to provide additional metrics into the |
| // UMA log. Should be called during MetricsService initialization only. |
| void RegisterMetricsProvider(std::unique_ptr<MetricsProvider> provider); |
| |
| // Check if this install was cloned or imaged from another machine. If a |
| // clone is detected, reset the client id and low entropy source. This |
| // should not be called more than once. |
| void CheckForClonedInstall(); |
| |
| // Checks if the cloned install detector says that client ids should be reset. |
| bool ShouldResetClientIdsOnClonedInstall(); |
| |
| // Clears the stability metrics that are saved in local state. |
| void ClearSavedStabilityMetrics(); |
| |
| // Marks current histograms as reported by snapshotting them, without |
| // actually saving the deltas. At a higher level, this is used to throw |
| // away new histogram samples (since the last log) so that they will not |
| // be included in the next log. |
| void MarkCurrentHistogramsAsReported(); |
| |
| #if BUILDFLAG(IS_CHROMEOS_ASH) |
| // Binds a user log store to store unsent logs. This log store will be |
| // fully managed by MetricsLogStore. This will no-op if another log store has |
| // already been set. |
| // |
| // If this is called before initial logs are recorded, then histograms |
| // recorded before user log store is set will be included with user histograms |
| // when initial logs are recorded. |
| // |
| // If this is called after initial logs are recorded, then this will flush all |
| // logs recorded before swapping to |user_log_store|. |
| void SetUserLogStore(std::unique_ptr<UnsentLogStore> user_log_store); |
| |
| // Unbinds the user log store. If there was no user log store, then this does |
| // nothing. |
| // |
| // If this is called before initial logs are recorded, then histograms and the |
| // current log will be discarded. |
| // |
| // If called after initial logs are recorded, then this will flush all logs |
| // before the user log store is unset. |
| void UnsetUserLogStore(); |
| |
| // Returns true if a user log store has been bound. |
| bool HasUserLogStore(); |
| |
| // Initializes per-user metrics collection. Logs recorded during a user |
| // session will be stored within each user's directory and consent to send |
| // these logs will be controlled by each user. Logs recorded before any user |
| // logs in or during guest sessions (given device owner has consented) will be |
| // stored in local_state. |
| // |
| // This is in its own function because the MetricsService is created very |
| // early on and a user metrics service may have dependencies on services that |
| // are created happen after MetricsService is initialized. |
| void InitPerUserMetrics(); |
| |
| // Returns the current user metrics consent if it should be applied to |
| // determine metrics reporting state. |
| // |
| // See comments at MetricsServiceClient::GetCurrentUserMetricsConsent() for |
| // more details. |
| absl::optional<bool> GetCurrentUserMetricsConsent() const; |
| |
| // Returns the current logged in user id. See comments at |
| // MetricsServiceClient::GetCurrentUserId() for more details. |
| absl::optional<std::string> GetCurrentUserId() const; |
| |
| // Updates the current user metrics consent. No-ops if no user has logged in. |
| void UpdateCurrentUserMetricsConsent(bool user_metrics_consent); |
| #endif // BUILDFLAG(IS_CHROMEOS_ASH) |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| // Forces the client ID to be reset and generates a new client ID. This will |
| // be called when a user re-consents to metrics collection and the user had |
| // consented in the past. |
| // |
| // This is to preserve the pseudo-anonymous identifier <client_id, user_id>. |
| void ResetClientId(); |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| |
| variations::SyntheticTrialRegistry* GetSyntheticTrialRegistry(); |
| |
| // Returns the delay before the init tasks (to asynchronously initialize |
| // metrics providers) run. |
| base::TimeDelta GetInitializationDelay(); |
| |
| // Returns the delay before the task to update the "last alive timestamp" is |
| // run. |
| base::TimeDelta GetUpdateLastAliveTimestampDelay(); |
| |
| MetricsLogStore* LogStoreForTest() { |
| return reporting_service_.metrics_log_store(); |
| } |
| |
| // Test hook to safely stage the current log in the log store. |
| bool StageCurrentLogForTest(); |
| |
| MetricsLog* GetCurrentLogForTest() { return current_log_.get(); } |
| |
| DelegatingProvider* GetDelegatingProviderForTesting() { |
| return &delegating_provider_; |
| } |
| |
| // Adds/Removes a logs observer. Observers are notified when a log is newly |
| // created and is now known by the metrics service. This may occur when |
| // closing a log, or when loading a log from persistent storage. Observers are |
| // also notified when an event occurs on the log (e.g., log is staged, |
| // uploaded, etc.). See MetricsLogsEventManager::LogEvent for more details. |
| void AddLogsObserver(MetricsLogsEventManager::Observer* observer); |
| void RemoveLogsObserver(MetricsLogsEventManager::Observer* observer); |
| |
| MetricsServiceObserver* logs_event_observer() { |
| return logs_event_observer_.get(); |
| } |
| |
| // Observers will be notified when the enablement state changes. The callback |
| // should accept one boolean argument, which will signal whether or not the |
| // metrics collection has been enabled. |
| base::CallbackListSubscription AddEnablementObserver( |
| const base::RepeatingCallback<void(bool)>& observer); |
| |
| #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_IOS) |
| bool IsInForegroundForTesting() const { return is_in_foreground_; } |
| #endif |
| |
| // Creates a new MetricsLog instance with the given |log_type|. |
| std::unique_ptr<MetricsLog> CreateLogForTesting( |
| MetricsLog::LogType log_type) { |
| return CreateLog(log_type); |
| } |
| |
| protected: |
| // Sets the persistent system profile. Virtual for tests. |
| virtual void SetPersistentSystemProfile(const std::string& serialized_proto, |
| bool complete); |
| |
| // Records the current environment (system profile) in |log|, and persists |
| // the results in prefs. |
| // Exposed for testing. |
| static std::string RecordCurrentEnvironmentHelper( |
| MetricsLog* log, |
| PrefService* local_state, |
| DelegatingProvider* delegating_provider); |
| |
| // The MetricsService has a lifecycle that is stored as a state. |
| // See metrics_service.cc for description of this lifecycle. |
| enum State { |
| CONSTRUCTED, // Constructor was called. |
| INITIALIZED, // InitializeMetricsRecordingState() was called. |
| INIT_TASK_SCHEDULED, // Waiting for deferred init tasks to finish. |
| INIT_TASK_DONE, // Waiting for timer to send initial log. |
| SENDING_LOGS, // Sending logs and creating new ones when we run out. |
| }; |
| |
| State state() const { return state_; } |
| |
| private: |
| // The current state of recording for the MetricsService. The state is UNSET |
| // until set to something else, at which point it remains INACTIVE or ACTIVE |
| // for the lifetime of the object. |
| enum RecordingState { |
| INACTIVE, |
| ACTIVE, |
| UNSET, |
| }; |
| |
| // The result of a call to FinalizeLog(). |
| struct FinalizedLog { |
| FinalizedLog(); |
| ~FinalizedLog(); |
| |
| // This type is move only. |
| FinalizedLog(FinalizedLog&& other); |
| FinalizedLog& operator=(FinalizedLog&& other); |
| |
| // The size of the uncompressed log data. This is only used for calculating |
| // some metrics. |
| size_t uncompressed_log_size; |
| |
| // A LogInfo object representing the log, which contains its compressed |
| // data, hash, signature, timestamp, and some metadata. |
| std::unique_ptr<UnsentLogStore::LogInfo> log_info; |
| }; |
| |
| // Writes snapshots of histograms owned by the StatisticsRecorder to a log. |
| // Does not take ownership of the log. |
| // TODO(crbug/1423653): Although this class takes in |required_flags| in its |
| // constructor to filter the StatisticsRecorder histograms being put into |
| // the log, the |histogram_snapshot_manager_| is not aware of this. So if |
| // the |histogram_snapshot_manager_| is passed to some other caller, this |
| // caller will need to manually filter the histograms. Re-factor the code so |
| // that this is not needed. |
| class MetricsLogHistogramWriter { |
| public: |
| explicit MetricsLogHistogramWriter(MetricsLog* log); |
| |
| MetricsLogHistogramWriter(MetricsLog* log, |
| base::HistogramBase::Flags required_flags); |
| |
| MetricsLogHistogramWriter(const MetricsLogHistogramWriter&) = delete; |
| MetricsLogHistogramWriter& operator=(const MetricsLogHistogramWriter&) = |
| delete; |
| |
| ~MetricsLogHistogramWriter(); |
| |
| // Snapshots the deltas of histograms known by the StatisticsRecorder and |
| // writes them to the log passed in the constructor. This also marks the |
| // samples (the deltas) as logged. |
| void SnapshotStatisticsRecorderDeltas(); |
| |
| // Snapshots the unlogged samples of histograms known by the |
| // StatisticsRecorder and writes them to the log passed in the constructor. |
| // Note that unlike SnapshotStatisticsRecorderDeltas(), this does not mark |
| // the samples as logged. To do so, a call to MarkUnloggedSamplesAsLogged() |
| // (in |histogram_snapshot_manager_|) should be made. |
| void SnapshotStatisticsRecorderUnloggedSamples(); |
| |
| base::HistogramSnapshotManager* histogram_snapshot_manager() { |
| return histogram_snapshot_manager_.get(); |
| } |
| |
| base::StatisticsRecorder::SnapshotTransactionId snapshot_transaction_id() { |
| return snapshot_transaction_id_; |
| } |
| |
| private: |
| // Used to select which histograms to record when calling |
| // SnapshotStatisticsRecorderHistograms() or |
| // SnapshotStatisticsRecorderUnloggedSamples(). |
| const base::HistogramBase::Flags required_flags_; |
| |
| // Used to write histograms to the log passed in the constructor. |
| std::unique_ptr<base::HistogramFlattener> flattener_; |
| |
| // Used to snapshot histograms. |
| std::unique_ptr<base::HistogramSnapshotManager> histogram_snapshot_manager_; |
| |
| // The snapshot transaction ID of a call to either |
| // SnapshotStatisticsRecorderDeltas() or |
| // SnapshotStatisticsRecorderUnloggedSamples(). |
| base::StatisticsRecorder::SnapshotTransactionId snapshot_transaction_id_; |
| }; |
| |
| // Loads "independent" metrics from a metrics provider and executes a |
| // callback when complete, which could be immediate or after some |
| // execution on a background thread. |
| class IndependentMetricsLoader { |
| public: |
| explicit IndependentMetricsLoader(std::unique_ptr<MetricsLog> log, |
| std::string app_version, |
| std::string signing_key); |
| |
| IndependentMetricsLoader(const IndependentMetricsLoader&) = delete; |
| IndependentMetricsLoader& operator=(const IndependentMetricsLoader&) = |
| delete; |
| |
| ~IndependentMetricsLoader(); |
| |
| // Call ProvideIndependentMetrics (which may execute on a background thread) |
| // for the |metrics_provider| and execute the |done_callback| when complete |
| // with the result (true if successful). |done_callback| must own |this|. |
| void Run(base::OnceCallback<void(bool)> done_callback, |
| MetricsProvider* metrics_provider); |
| |
| // Finalizes/serializes |log_|, and stores the result in |finalized_log_|. |
| // Should only be called once, after |log_| has been filled. |
| void FinalizeLog(); |
| |
| // Returns whether FinalizeLog() was called. |
| bool HasFinalizedLog(); |
| |
| // Extracts |finalized_log_|. Should be only called once, after |
| // FinalizeLog() has been called. No more operations should be done after |
| // this. |
| FinalizedLog ReleaseFinalizedLog(); |
| |
| private: |
| std::unique_ptr<MetricsLog> log_; |
| std::unique_ptr<base::HistogramFlattener> flattener_; |
| std::unique_ptr<base::HistogramSnapshotManager> snapshot_manager_; |
| bool run_called_ = false; |
| |
| // Used for finalizing |log_| in FinalizeLog(). |
| const std::string app_version_; |
| const std::string signing_key_; |
| |
| // Stores the result of FinalizeLog(). |
| FinalizedLog finalized_log_; |
| bool finalize_log_called_ = false; |
| bool release_finalized_log_called_ = false; |
| }; |
| |
| // Gets the LogStore for UMA logs. |
| MetricsLogStore* log_store() { |
| return reporting_service_.metrics_log_store(); |
| } |
| |
| // Calls into the client to initialize some system profile metrics. |
| void StartInitTask(); |
| |
| // Callback that moves the state to INIT_TASK_DONE. When this is called, the |
| // state should be INIT_TASK_SCHEDULED. |
| void FinishedInitTask(); |
| |
| void OnUserAction(const std::string& action, base::TimeTicks action_time); |
| |
| // Get the amount of uptime since this process started and since the last |
| // call to this function. Also updates the cumulative uptime metric (stored |
| // as a pref) for uninstall. Uptimes are measured using TimeTicks, which |
| // guarantees that it is monotonic and does not jump if the user changes |
| // their clock. The TimeTicks implementation also makes the clock not |
| // count time the computer is suspended. |
| void GetUptimes(PrefService* pref, |
| base::TimeDelta* incremental_uptime, |
| base::TimeDelta* uptime); |
| |
| // Turns recording on or off. |
| // DisableRecording() also forces a persistent save of logging state (if |
| // anything has been recorded, or transmitted). |
| void EnableRecording(); |
| void DisableRecording(); |
| |
| // If in_idle is true, sets idle_since_last_transmission to true. |
| // If in_idle is false and idle_since_last_transmission_ is true, sets |
| // idle_since_last_transmission to false and starts the timer (provided |
| // starting the timer is permitted). |
| void HandleIdleSinceLastTransmission(bool in_idle); |
| |
| // Set up client ID, session ID, etc. |
| void InitializeMetricsState(); |
| |
| // Opens a new log for recording user experience metrics. If |call_providers| |
| // is true, OnDidCreateMetricsLog() of providers will be called right after |
| // opening the new log. |
| void OpenNewLog(bool call_providers = true); |
| |
| // Closes out the current log after adding any last information. |async| |
| // determines whether finalizing the log will be done in a background thread. |
| // |log_stored_callback| will be run (on the main thread) after the finalized |
| // log is stored. Note that when |async| is true, the closed log could end up |
| // not being stored (see MaybeCleanUpAndStoreFinalizedLog()). Regardless, |
| // |log_stored_callback| is still run. Note that currently, there is only |
| // support to close one log asynchronously at a time (this should be enforced |
| // by the caller). |
| void CloseCurrentLog( |
| bool async, |
| MetricsLogsEventManager::CreateReason reason, |
| base::OnceClosure log_stored_callback = base::DoNothing()); |
| |
| // Stores the |finalized_log| in |log_store()|. |
| void StoreFinalizedLog(MetricsLog::LogType log_type, |
| MetricsLogsEventManager::CreateReason reason, |
| base::OnceClosure done_callback, |
| FinalizedLog finalized_log); |
| |
| // Calls MarkUnloggedSamplesAsLogged() on |log_histogram_writer| and stores |
| // the |finalized_log| (see StoreFinalizedLog()), but only if the |
| // StatisticRecorder's last transaction ID is the same as the one from |
| // |log_histogram_writer| at the time of calling. See comments in the |
| // implementation for more details. |
| void MaybeCleanUpAndStoreFinalizedLog( |
| std::unique_ptr<MetricsLogHistogramWriter> log_histogram_writer, |
| MetricsLog::LogType log_type, |
| MetricsLogsEventManager::CreateReason reason, |
| base::OnceClosure done_callback, |
| FinalizedLog finalized_log); |
| |
| // Pushes the text of the current and staged logs into persistent storage. |
| void PushPendingLogsToPersistentStorage( |
| MetricsLogsEventManager::CreateReason reason); |
| |
| // Ensures that scheduler is running, assuming the current settings are such |
| // that metrics should be reported. If not, this is a no-op. |
| void StartSchedulerIfNecessary(); |
| |
| // Starts the process of uploading metrics data. |
| void StartScheduledUpload(); |
| |
| // Called by the client via a callback when final log info collection is |
| // complete. |
| void OnFinalLogInfoCollectionDone(); |
| |
| // Called via a callback after a periodic ongoing log (created through the |
| // MetricsRotationScheduler) was stored in |log_store()|. |
| void OnAsyncPeriodicOngoingLogStored(); |
| |
| // Prepares the initial stability log, which is only logged when the previous |
| // run of Chrome crashed. This log contains any stability metrics left over |
| // from that previous run, and only these stability metrics. It uses the |
| // system profile from the previous session. |prefs_previous_version| is used |
| // to validate the version number recovered from the system profile. Returns |
| // true if a log was created. |
| bool PrepareInitialStabilityLog(const std::string& prefs_previous_version); |
| |
| // Creates a new MetricsLog instance with the given |log_type|. |
| std::unique_ptr<MetricsLog> CreateLog(MetricsLog::LogType log_type); |
| |
| // Records the current environment (system profile) in |log|, and persists |
| // the results in prefs and GlobalPersistentSystemProfile. |
| void RecordCurrentEnvironment(MetricsLog* log, bool complete); |
| |
| // Handle completion of PrepareProviderMetricsLog which is run as a |
| // background task. |
| void PrepareProviderMetricsLogDone( |
| std::unique_ptr<IndependentMetricsLoader> loader, |
| bool success); |
| |
| // Record a single independent profile and associated histogram from |
| // metrics providers. If this returns true, one was found and there may |
| // be more. |
| bool PrepareProviderMetricsLog(); |
| |
| // Records one independent histogram log and then reschedules itself to |
| // check for others. The interval is so as to not adversely impact the UI. |
| void PrepareProviderMetricsTask(); |
| |
| // Updates the "last live" browser timestamp and schedules the next update. |
| void UpdateLastLiveTimestampTask(); |
| |
| // Returns whether it is too early to close a log. |
| bool IsTooEarlyToCloseLog(); |
| |
| // Called if this install is detected as cloned. |
| void OnClonedInstallDetected(); |
| |
| // Snapshots histogram deltas using the passed |log_histogram_writer| and then |
| // finalizes |log| by calling FinalizeLog(). |log|, |current_app_version| and |
| // |signing_key| are used to finalize the log (see FinalizeLog()). |
| // Semantically, this is equivalent to SnapshotUnloggedSamplesAndFinalizeLog() |
| // followed by MarkUnloggedSamplesAsLogged(). |
| static FinalizedLog SnapshotDeltasAndFinalizeLog( |
| std::unique_ptr<MetricsLogHistogramWriter> log_histogram_writer, |
| std::unique_ptr<MetricsLog> log, |
| bool truncate_events, |
| absl::optional<ChromeUserMetricsExtension::RealLocalTime> close_time, |
| std::string&& current_app_version, |
| std::string&& signing_key); |
| |
| // Snapshots unlogged histogram samples using the passed |
| // |log_histogram_writer| and then finalizes |log| by calling FinalizeLog(). |
| // |log|, |current_app_version| and |signing_key| are used to finalize the log |
| // (see FinalizeLog()). Note that unlike SnapshotDeltasAndFinalizeLog(), this |
| // does not own the passed |log_histogram_writer|, because it should be |
| // available to eventually mark the unlogged samples as logged. |
| static FinalizedLog SnapshotUnloggedSamplesAndFinalizeLog( |
| MetricsLogHistogramWriter* log_histogram_writer, |
| std::unique_ptr<MetricsLog> log, |
| bool truncate_events, |
| absl::optional<ChromeUserMetricsExtension::RealLocalTime> close_time, |
| std::string&& current_app_version, |
| std::string&& signing_key); |
| |
| // Finalizes |log| (see MetricsLog::FinalizeLog()). The |signing_key| is used |
| // to compute a signature for the log. |
| static FinalizedLog FinalizeLog( |
| std::unique_ptr<MetricsLog> log, |
| bool truncate_events, |
| absl::optional<ChromeUserMetricsExtension::RealLocalTime> close_time, |
| const std::string& current_app_version, |
| const std::string& signing_key); |
| |
| // Sub-service for uploading logs. |
| MetricsReportingService reporting_service_; |
| |
| // The log that we are still appending to. |
| std::unique_ptr<MetricsLog> current_log_; |
| |
| // Used to manage various metrics reporting state prefs, such as client id, |
| // low entropy source and whether metrics reporting is enabled. Weak pointer. |
| const raw_ptr<MetricsStateManager> state_manager_; |
| |
| // Used to interact with the embedder. Weak pointer; must outlive |this| |
| // instance. |
| const raw_ptr<MetricsServiceClient> client_; |
| |
| // Registered metrics providers. |
| DelegatingProvider delegating_provider_; |
| |
| raw_ptr<PrefService> local_state_; |
| |
| base::ActionCallback action_callback_; |
| |
| // Indicate whether recording and reporting are currently happening. |
| // These should not be set directly, but by calling SetRecording and |
| // SetReporting. |
| RecordingState recording_state_; |
| |
| // Indicate whether test mode is enabled, where the initial log should never |
| // be cut, and logs are neither persisted nor uploaded. |
| bool test_mode_active_; |
| |
| // The progression of states made by the browser are recorded in the following |
| // state. |
| State state_; |
| |
| // Whether the MetricsService object has received any notifications since |
| // the last time a transmission was sent. |
| bool idle_since_last_transmission_; |
| |
| // A number that identifies the how many times the app has been launched. |
| int session_id_; |
| |
| // The scheduler for determining when log rotations should happen. |
| std::unique_ptr<MetricsRotationScheduler> rotation_scheduler_; |
| |
| // Stores the time of the first call to |GetUptimes()|. |
| base::TimeTicks first_updated_time_; |
| |
| // Stores the time of the last call to |GetUptimes()|. |
| base::TimeTicks last_updated_time_; |
| |
| // Indicates if loading of independent metrics is currently active. |
| bool independent_loader_active_ = false; |
| |
| // Indicates whether or not there is currently a periodic ongoing log being |
| // finalized (or is scheduled to be finalized). |
| bool pending_ongoing_log_ = false; |
| |
| // Stores the time when we last posted a task to finalize a periodic ongoing |
| // log asynchronously. |
| base::TimeTicks async_ongoing_log_posted_time_; |
| |
| // Logs event manager to keep track of the various logs that the metrics |
| // service interacts with. An unowned pointer of this instance is passed down |
| // to various objects that are owned by this class. |
| MetricsLogsEventManager logs_event_manager_; |
| |
| // An observer that observes all events notified through |logs_event_manager_| |
| // since the creation of this MetricsService instance. This is only created |
| // if this is a debug build, or the |kExportUmaLogsToFile| command line flag |
| // is passed. This is primarily used by the chrome://metrics-internals debug |
| // page. |
| std::unique_ptr<MetricsServiceObserver> logs_event_observer_; |
| |
| // A set of observers that keeps track of the metrics reporting state. |
| base::RepeatingCallbackList<void(bool)> enablement_observers_; |
| |
| // Subscription for a callback that runs if this install is detected as |
| // cloned. |
| base::CallbackListSubscription cloned_install_subscription_; |
| |
| #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_IOS) |
| // Indicates whether OnAppEnterForeground() (true) or OnAppEnterBackground |
| // (false) was called. |
| bool is_in_foreground_ = false; |
| #endif |
| |
| FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, ActiveFieldTrialsReported); |
| FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, IsPluginProcess); |
| FRIEND_TEST_ALL_PREFIXES(::ChromeMetricsServiceClientTest, |
| TestRegisterMetricsServiceProviders); |
| FRIEND_TEST_ALL_PREFIXES(::IOSChromeMetricsServiceClientTest, |
| TestRegisterMetricsServiceProviders); |
| SEQUENCE_CHECKER(sequence_checker_); |
| |
| // Weak pointers factory used to post task on different threads. All weak |
| // pointers managed by this factory have the same lifetime as MetricsService. |
| base::WeakPtrFactory<MetricsService> self_ptr_factory_{this}; |
| }; |
| |
| } // namespace metrics |
| |
| #endif // COMPONENTS_METRICS_METRICS_SERVICE_H_ |