// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROMEOS_ASH_COMPONENTS_NETWORK_CELLULAR_METRICS_LOGGER_H_
#define CHROMEOS_ASH_COMPONENTS_NETWORK_CELLULAR_METRICS_LOGGER_H_
#include <optional>
#include "base/component_export.h"
#include "base/containers/flat_map.h"
#include "base/gtest_prod_util.h"
#include "base/memory/raw_ptr.h"
#include "base/scoped_observation.h"
#include "base/time/time.h"
#include "base/timer/elapsed_timer.h"
#include "base/timer/timer.h"
#include "chromeos/ash/components/login/login_state/login_state.h"
#include "chromeos/ash/components/network/managed_network_configuration_handler.h"
#include "chromeos/ash/components/network/network_connection_observer.h"
#include "chromeos/ash/components/network/network_state_handler.h"
#include "chromeos/ash/components/network/network_state_handler_observer.h"
namespace ash {
class CellularESimProfileHandler;
class CellularMetricsLoggerTest;
class ESimFeatureUsageMetrics;
class EnterpriseESimFeatureUsageMetrics;
class NetworkConnectionHandler;
class NetworkState;
// Cellular network SIM types.
enum class SimType {
kPSim,
kESim,
};
// Class for tracking cellular network related metrics.
//
// This class adds observers on network state and makes the following
// measurements on cellular networks:
// 1. Time to connected.
// 2. Connected states and non-user initiated disconnections.
// 3. Activation status at login.
// 4. Cellular network usage type.
//
// Note: This class does not start logging metrics until Init() is
// invoked.
class COMPONENT_EXPORT(CHROMEOS_NETWORK) CellularMetricsLogger
: public NetworkStateHandlerObserver,
public LoginState::Observer,
public NetworkConnectionObserver {
public:
// Histograms associated with SIM Pin operations.
static const char kSimPinChangeSuccessHistogram[];
static const char kManagedSimPinUnblockSuccessHistogram[];
static const char kManagedSimPinUnlockSuccessHistogram[];
static const char kSimPinRemoveLockSuccessHistogram[];
static const char kSimPinRequireLockSuccessHistogram[];
static const char kRestrictedSimPinUnblockSuccessHistogram[];
static const char kRestrictedSimPinUnlockSuccessHistogram[];
static const char kUnmanagedSimPinUnblockSuccessHistogram[];
static const char kUnmanagedSimPinUnlockSuccessHistogram[];
static const char kUnrestrictedSimPinUnblockSuccessHistogram[];
static const char kUnrestrictedSimPinUnlockSuccessHistogram[];
static const char kChangePinSuccessSimPinLockPolicyHistogram[];
static const char kRequirePinSuccessSimPinLockPolicyHistogram[];
// Histograms associated with user initiated connection success.
static const char kESimUserInitiatedConnectionResultHistogram[];
static const char kPSimUserInitiatedConnectionResultHistogram[];
// Histograms associated with all connection success.
static const char kESimAllConnectionResultHistogram[];
static const char kESimPolicyAllConnectionResultHistogram[];
static const char kPSimAllConnectionResultHistogram[];
// Histograms associated with SIM Lock notification events.
static const char kSimLockNotificationEventHistogram[];
static const char kSimLockNotificationLockType[];
// The amount of time after cellular device is added to device list,
// after which cellular device is considered initialized.
static const base::TimeDelta kInitializationTimeout;
// Histograms associated with SIM Lock status on the active network.
static const char kUnrestrictedActiveNetworkSIMLockStatus[];
static const char kRestrictedActiveNetworkSIMLockStatus[];
// PIN operations that are tracked by metrics.
enum class SimPinOperation {
kRequireLock = 0,
kRemoveLock = 1,
kUnlock = 2,
kUnblock = 3,
kChange = 4,
};
// SIM lock notification events
enum class SimLockNotificationEvent {
kShown = 0,
kClicked = 1,
kDismissed = 2,
kMaxValue = kDismissed
};
// SIM pin lock type.
enum class SimPinLockType {
kPinLocked = 0,
kPukLocked = 1,
kUnlocked = 2,
kCarrierLocked = 3,
kMaxValue = kCarrierLocked
};
// Records the result of pin operations performed.
static void RecordSimPinOperationResult(
const SimPinOperation& pin_operation,
const bool allow_cellular_sim_lock,
const std::optional<std::string>& shill_error_name = std::nullopt);
// Records the SIM lock notification event.
static void RecordSimLockNotificationEvent(
const SimLockNotificationEvent notification_event);
// Records the SIM lock type when the notification is surfaced.
static void RecordSimLockNotificationLockType(
const std::string& sim_lock_type);
CellularMetricsLogger();
CellularMetricsLogger(const CellularMetricsLogger&) = delete;
CellularMetricsLogger& operator=(const CellularMetricsLogger&) = delete;
~CellularMetricsLogger() override;
void Init(NetworkStateHandler* network_state_handler,
NetworkConnectionHandler* network_connection_handler,
CellularESimProfileHandler* cellular_esim_profile_handler,
ManagedNetworkConfigurationHandler*
managed_network_configuration_handler);
// LoginState::Observer:
void LoggedInStateChanged() override;
// NetworkStateHandlerObserver::
void DeviceListChanged() override;
void NetworkListChanged() override;
void NetworkConnectionStateChanged(const NetworkState* network) override;
void OnShuttingDown() override;
// NetworkConnectionObserver::
void ConnectSucceeded(const std::string& service_path) override;
void ConnectFailed(const std::string& service_path,
const std::string& error_name) override;
void DisconnectRequested(const std::string& service_path) override;
private:
friend class CellularMetricsLoggerTest;
FRIEND_TEST_ALL_PREFIXES(CellularMetricsLoggerTest,
DuplicateCellularServiceGuids);
FRIEND_TEST_ALL_PREFIXES(CellularMetricsLoggerTest, CellularConnectResult);
FRIEND_TEST_ALL_PREFIXES(CellularMetricsLoggerTest,
CancellationDuringConnecting);
FRIEND_TEST_ALL_PREFIXES(CellularMetricsLoggerTest,
UserInitiatedConnectionResult);
FRIEND_TEST_ALL_PREFIXES(CellularMetricsLoggerTest,
CellularESimProfileStatusAtLoginTest);
FRIEND_TEST_ALL_PREFIXES(CellularMetricsLoggerTest, CellularUsageCountTest);
FRIEND_TEST_ALL_PREFIXES(CellularMetricsLoggerTest,
CellularUsageCountDongleTest);
FRIEND_TEST_ALL_PREFIXES(CellularMetricsLoggerTest,
CellularPSimActivationStateAtLoginTest);
FRIEND_TEST_ALL_PREFIXES(CellularMetricsLoggerTest,
CellularTimeToConnectedTest);
FRIEND_TEST_ALL_PREFIXES(CellularMetricsLoggerTest,
CellularDisconnectionsTest);
FRIEND_TEST_ALL_PREFIXES(NetworkDeviceHandlerTest, RequirePin);
FRIEND_TEST_ALL_PREFIXES(NetworkDeviceHandlerTest, EnterPinOnUnmanagedDevice);
FRIEND_TEST_ALL_PREFIXES(NetworkDeviceHandlerTest, EnterPinOnManagedDevice);
FRIEND_TEST_ALL_PREFIXES(NetworkDeviceHandlerTest,
UnblockPinOnUnmanagedDevice);
FRIEND_TEST_ALL_PREFIXES(NetworkDeviceHandlerTest, UnblockPinOnManagedDevice);
FRIEND_TEST_ALL_PREFIXES(NetworkDeviceHandlerTest, ChangePin);
// The amount of time after a disconnect request within which any
// disconnections are considered user initiated.
static const base::TimeDelta kDisconnectRequestTimeout;
// Stores connection related information for a cellular network.
struct ConnectionInfo {
explicit ConnectionInfo(const std::string& network_guid);
ConnectionInfo(const std::string& network_guid,
bool is_connected,
bool is_connecting);
~ConnectionInfo();
const std::string network_guid;
std::optional<bool> is_connected;
bool is_connecting = false;
// Tracks whether a disconnect was requested from chrome on a network that
// was previously in the connecting state. This field is set back to false
// when shill connection failures are checked in
// NetworkConnectionStateChanged().
bool disconnect_requested = false;
std::optional<base::TimeTicks> last_disconnect_request_time;
std::optional<base::TimeTicks> last_connect_start_time;
};
// Usage type for cellular network. These values are persisted to logs.
// Entries should not be renumbered and numeric values should never
// be reused.
enum class CellularUsage {
kConnectedAndOnlyNetwork = 0,
kConnectedWithOtherNetwork = 1,
kNotConnected = 2,
kMaxValue = kNotConnected
};
// Activation state for PSim cellular network.
// These values are persisted to logs. Entries should not be renumbered
// and numeric values should never be reused.
enum class PSimActivationState {
kActivated = 0,
kActivating = 1,
kNotActivated = 2,
kPartiallyActivated = 3,
kUnknown = 4,
kMaxValue = kUnknown
};
// Profile status for eSIM cellular network.
// These values are persisted to logs. Entries should not be renumbered
// and numeric values should never be reused.
enum class ESimProfileStatus {
kActive = 0,
kActiveWithPendingProfiles = 1,
kPendingProfilesOnly = 2,
kNoProfiles = 3,
kMaxValue = kNoProfiles
};
// Cellular connection state. These values are persisted to logs.
// Entries should not be renumbered and numeric values should
// never be reused.
enum class ConnectionState {
kConnected = 0,
kDisconnected = 1,
kMaxValue = kDisconnected
};
// Result of PIN operations.
// These values are persisted to logs. Entries should not be renumbered
// and numeric values should never be reused.
// Note: With the exception of Success, enums should match the
// error names listed near the top of NetworkDeviceHandler.
enum class SimPinOperationResult {
kSuccess = 0,
kErrorDeviceMissing = 1,
kErrorFailure = 2,
kErrorIncorrectPin = 3,
kErrorNotFound = 4,
kErrorNotSupported = 5,
kErrorPinBlocked = 6,
kErrorPinRequired = 7,
kErrorTimeout = 8,
kErrorUnknown = 9,
kErrorWrongState = 10,
kMaxValue = kErrorWrongState,
};
// This enum is used to track the connection results from
// NetworkConnectionHandler. With the exception of kSuccess and kUnknown,
// these enums are mapped to relevant NetworkConnectionHandler errors
// associated to user initiated connection errors.
// These values are persisted to logs. Entries should not be renumbered
// and numeric values should never be reused.
enum class ConnectResult {
kSuccess = 0,
kUnknown = 1,
kInvalidGuid = 2,
kInvalidState = 3,
kCanceled = 4,
kNotConfigured = 5,
kBlocked = 6,
kCellularInhibitFailure = 7,
kESimProfileIssue = 8,
kCellularOutOfCredits = 9,
kSimPinPukLocked = 10,
kConnectFailed = 11,
kNotConnected = 12,
kActivateFailed = 13,
kEnabledOrDisabledWhenNotAvailable = 14,
kErrorCellularDeviceBusy = 15,
kErrorConnectTimeout = 16,
kConnectableCellularTimeout = 17,
kSimCarrierLocked = 18,
kMaxValue = kSimCarrierLocked,
};
// Result of state changes to a cellular network triggered by any connection
// attempt. With the exception of kSuccess and kUnknown, these enums are
// mapped directly to Shill errors. These values are persisted to logs.
// Entries should not be renumbered and numeric values should never be reused.
enum class ShillConnectResult {
kSuccess = 0,
kUnknown = 1,
kFailedToConnect = 2,
kDhcpFailure = 3,
kDnsLookupFailure = 4,
kEapAuthentication = 5,
kEapLocalTls = 6,
kEapRemoteTls = 7,
kOutOfRange = 8,
kPinMissing = 9,
kNoFailure = 10,
kNotAssociated = 11,
kNotAuthenticated = 12,
kTooManySTAs = 13,
kBadPassphrase = 14,
kBadWepKey = 15,
kErrorSimPinPukLocked = 16,
kErrorNotRegistered = 17,
kErrorSimCarrierLocked = 18,
kMaxValue = kErrorSimCarrierLocked,
};
// Convert shill error name string to SimPinOperationResult enum.
static SimPinOperationResult GetSimPinOperationResultForShillError(
const std::string& shill_error_name);
// Converts a NetworkConnectionHandler string error to a ConnectResult enum.
static ConnectResult NetworkConnectionErrorToConnectResult(
const std::string& error_name);
// Converts a Shill error string to a ShillConnectResult enum.
static ShillConnectResult ShillErrorToConnectResult(
const std::string& error_name);
static void LogCellularUserInitiatedConnectionSuccessHistogram(
ConnectResult start_connect_result,
SimType sim_type);
// Returns null if there is no network with the given path or if the
// network is non-cellular.
const NetworkState* GetCellularNetwork(const std::string& service_path);
// Convert shill activation state string to PSimActivationState enum
PSimActivationState PSimActivationStateToEnum(const std::string& state);
// Helper method to save cellular disconnections histogram.
void LogCellularDisconnectionsHistogram(ConnectionState connection_state,
SimType sim_type,
bool is_managed_by_policy);
void LogCellularAllConnectionSuccessHistogram(
ShillConnectResult start_connect_result,
SimType sim_type,
bool is_managed_by_policy);
void OnInitializationTimeout();
// Tracks cellular network connection state and logs time to connected.
void CheckForTimeToConnectedMetric(const NetworkState* network);
// Tracks current cellular connection status and logs the metric.
// Current connection can be in one of the three states:
// (Connected/PIN_Locked/PUK_Blocked). This will be logged when a
// switch happens from no connection to an active connection or
// from one connection to another.
void CheckForSIMStatusMetric(const NetworkState* network);
// Tracks cellular network connected states and non user initiated
// disconnections.
void CheckForConnectionStateMetric(const NetworkState* network);
// Tracks the activation state of the PSim cellular network if available and
// if |is_psim_activation_state_logged_| is false.
void CheckForPSimActivationStateMetric();
// Tracks the activation state of eSIM cellular networks if available and
// if |is_esim_profile_status_logged_| is false.
void CheckForESimProfileStatusMetric();
// Tracks failed connection attempts.
void CheckForShillConnectionFailureMetric(const NetworkState* network);
// This checks the state of connected networks and logs
// cellular network usage histogram. Histogram is only logged
// when usage state changes.
void CheckForCellularUsageMetrics();
// Tracks how many eSIM profiles are installed on the device and how many pSIM
// networks are available on the device if |is_service_count_logged_| is true.
void CheckForCellularServiceCountMetric();
// Tracks the state of the Allow APN Modification policy at login.
void CheckForApnPolicyMetric();
// Handles eSIM Standard Feature Usage Logging metrics when the cellular usage
// changes for an eSIM network.
void HandleESimFeatureUsageChange(CellularUsage last_esim_cellular_usage,
CellularUsage current_usage,
bool is_managed_by_policy);
// Returns the ConnectionInfo for given |cellular_network_guid|.
ConnectionInfo* GetConnectionInfoForCellularNetwork(
const std::string& cellular_network_guid);
// Tracks the last cellular network usage state.
std::optional<CellularUsage> last_cellular_usage_;
// Tracks the last PSim cellular network usage state.
std::optional<CellularUsage> last_psim_cellular_usage_;
// Tracks the last time the PSim network's cellular usage changed.
std::optional<base::ElapsedTimer> psim_usage_elapsed_timer_;
// Tracks the last eSIM cellular network usage state.
std::optional<CellularUsage> last_esim_cellular_usage_;
// Tracks the last time eSIM network's cellular usage is managed or not.
bool last_managed_by_policy_ = false;
// Tracks the last time the eSIM network's cellular usage changed.
std::optional<base::ElapsedTimer> esim_usage_elapsed_timer_;
// Tracks whether cellular device is available or not.
bool is_cellular_available_ = false;
raw_ptr<NetworkStateHandler> network_state_handler_ = nullptr;
base::ScopedObservation<NetworkStateHandler, NetworkStateHandlerObserver>
network_state_handler_observer_{this};
raw_ptr<ManagedNetworkConfigurationHandler>
managed_network_configuration_handler_ = nullptr;
raw_ptr<NetworkConnectionHandler> network_connection_handler_ = nullptr;
raw_ptr<CellularESimProfileHandler> cellular_esim_profile_handler_ = nullptr;
// A timer to wait for cellular initialization. This is useful
// to avoid tracking intermediate states when cellular network is
// starting up.
base::OneShotTimer initialization_timer_;
// Stores the iccid of the most recently active network.
std::string last_active_network_iccid_;
// Tracks whether the PSim activation state is already logged for this
// session.
bool is_psim_activation_state_logged_ = false;
// Tracks whether the eSIM profile status is already logged for this
// session.
bool is_esim_profile_status_logged_ = false;
// Tracks whether service count is already logged for this session.
bool is_service_count_logged_ = false;
// Tracks whether apn policy state is already logged for this session.
bool is_apn_policy_logged_ = false;
// Stores connection information for all cellular networks.
base::flat_map<std::string, std::unique_ptr<ConnectionInfo>>
guid_to_connection_info_map_;
bool initialized_ = false;
// Tracks eSIM feature usage for the Standard Feature Usage Logging Framework.
std::unique_ptr<ESimFeatureUsageMetrics> esim_feature_usage_metrics_;
// Tracks enterprise eSIM feature usage for the Standard Feature Usage Logging
// Framework.
std::unique_ptr<EnterpriseESimFeatureUsageMetrics>
enterprise_esim_feature_usage_metrics_;
};
} // namespace ash
#endif // CHROMEOS_ASH_COMPONENTS_NETWORK_CELLULAR_METRICS_LOGGER_H_
Codebase Browser
chromium