// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/ash/components/network/metrics/network_metrics_helper.h"
#include "base/metrics/histogram_functions.h"
#include "base/notreached.h"
#include "base/strings/strcat.h"
#include "chromeos/ash/components/network/cellular_metrics_logger.h"
#include "chromeos/ash/components/network/metrics/connection_results.h"
#include "chromeos/ash/components/network/network_event_log.h"
#include "chromeos/ash/components/network/network_handler.h"
#include "chromeos/ash/components/network/network_state.h"
#include "chromeos/services/network_config/public/mojom/cros_network_config.mojom.h"
#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"
namespace ash {
namespace {
const char kNetworkMetricsPrefix[] = "Network.Ash.";
const char kAllConnectionResultSuffix[] = ".ConnectionResult.All";
const char kFilteredConnectionResultSuffix[] = ".ConnectionResult.Filtered";
const char kNonUserInitiatedConnectionResultSuffix[] =
".ConnectionResult.NonUserInitiated";
const char kUserInitiatedConnectionResultSuffix[] =
".ConnectionResult.UserInitiated";
const char kDisconnectionsWithoutUserActionSuffix[] =
".DisconnectionsWithoutUserAction";
const char kDisconnectionsWithoutUserActionShillErrorSuffix[] =
".DisconnectionsWithoutUserAction.ShillError";
const char kEnableTechnologyResultSuffix[] = ".EnabledState.Enable.Result";
const char kEnableTechnologyResultCodeSuffix[] =
".EnabledState.Enable.ResultCode";
const char kDisableTechnologyResultSuffix[] = ".EnabledState.Disable.Result";
const char kDisableTechnologyResultCodeSuffix[] =
".EnabledState.Disable.ResultCode";
const char kCellular[] = "Cellular";
const char kCellularESim[] = "Cellular.ESim";
const char kCellularPSim[] = "Cellular.PSim";
const char kPolicySuffix[] = ".Policy";
const char kEthernet[] = "Ethernet";
const char kEthernetEap[] = "Ethernet.Eap";
const char kEthernetNoEap[] = "Ethernet.NoEap";
const char kTether[] = "Tether";
const char kVPN[] = "VPN";
const char kVPNBuiltIn[] = "VPN.TypeBuiltIn";
const char kVPNThirdParty[] = "VPN.TypeThirdParty";
const char kVPNUnknown[] = "VPN.TypeUnknown";
const char kWifi[] = "WiFi";
const char kWifiOpen[] = "WiFi.SecurityOpen";
const char kWifiPasswordProtected[] = "WiFi.SecurityPasswordProtected";
NetworkStateHandler* GetNetworkStateHandler() {
return NetworkHandler::Get()->network_state_handler();
}
const std::optional<const std::string> GetTechnologyTypeSuffix(
const std::string& technology) {
// Note that Tether is a fake technology that does not correspond to shill
// technology type.
if (technology == shill::kTypeWifi)
return kWifi;
else if (technology == shill::kTypeEthernet)
return kEthernet;
else if (technology == shill::kTypeCellular)
return kCellular;
else if (technology == shill::kTypeVPN)
return kVPN;
return std::nullopt;
}
const std::vector<std::string> GetCellularNetworkTypeHistogams(
const NetworkState* network_state) {
std::vector<std::string> cellular_histograms{kCellular};
const char* cellular_sim_type =
network_state->eid().empty() ? kCellularPSim : kCellularESim;
cellular_histograms.emplace_back(cellular_sim_type);
if (network_state->IsManagedByPolicy()) {
cellular_histograms.emplace_back(
base::StrCat({cellular_sim_type, kPolicySuffix}));
}
return cellular_histograms;
}
const std::vector<std::string> GetEthernetNetworkTypeHistograms(
const NetworkState* network_state) {
std::vector<std::string> ethernet_histograms{kEthernet};
if (GetNetworkStateHandler()->GetEAPForEthernet(network_state->path(),
/*connected_only=*/true)) {
ethernet_histograms.emplace_back(kEthernetEap);
} else {
ethernet_histograms.emplace_back(kEthernetNoEap);
}
return ethernet_histograms;
}
const std::vector<std::string> GetWifiNetworkTypeHistograms(
const NetworkState* network_state) {
std::vector<std::string> wifi_histograms{kWifi};
if (network_state->GetMojoSecurity() ==
chromeos::network_config::mojom::SecurityType::kNone) {
wifi_histograms.emplace_back(kWifiOpen);
} else {
wifi_histograms.emplace_back(kWifiPasswordProtected);
}
return wifi_histograms;
}
const std::vector<std::string> GetTetherNetworkTypeHistograms(
const NetworkState* network_state) {
return {kTether};
}
const std::vector<std::string> GetVpnNetworkTypeHistograms(
const NetworkState* network_state) {
const std::string& vpn_provider_type = network_state->GetVpnProviderType();
if (vpn_provider_type.empty())
return {};
std::vector<std::string> vpn_histograms{kVPN};
if (vpn_provider_type == shill::kProviderThirdPartyVpn ||
vpn_provider_type == shill::kProviderArcVpn) {
vpn_histograms.emplace_back(kVPNThirdParty);
} else if (vpn_provider_type == shill::kProviderIKEv2 ||
vpn_provider_type == shill::kProviderL2tpIpsec ||
vpn_provider_type == shill::kProviderOpenVpn ||
vpn_provider_type == shill::kProviderWireGuard) {
vpn_histograms.emplace_back(kVPNBuiltIn);
} else {
DUMP_WILL_BE_NOTREACHED();
vpn_histograms.emplace_back(kVPNUnknown);
}
return vpn_histograms;
}
const std::vector<std::string> GetNetworkTypeHistogramNames(
const NetworkState* network_state) {
switch (network_state->GetNetworkTechnologyType()) {
case NetworkState::NetworkTechnologyType::kCellular:
return GetCellularNetworkTypeHistogams(network_state);
case NetworkState::NetworkTechnologyType::kEthernet:
return GetEthernetNetworkTypeHistograms(network_state);
case NetworkState::NetworkTechnologyType::kWiFi:
return GetWifiNetworkTypeHistograms(network_state);
case NetworkState::NetworkTechnologyType::kTether:
return GetTetherNetworkTypeHistograms(network_state);
case NetworkState::NetworkTechnologyType::kVPN:
return GetVpnNetworkTypeHistograms(network_state);
// There should not be connections requests for kEthernetEap type service.
// kEthernetEap exists only to store auth details for ethernet.
case NetworkState::NetworkTechnologyType::kEthernetEap:
[[fallthrough]];
case NetworkState::NetworkTechnologyType::kUnknown:
[[fallthrough]];
default:
return {};
}
}
} // namespace
// static
void NetworkMetricsHelper::LogAllConnectionResult(
const std::string& guid,
bool is_auto_connect,
bool is_repeated_error,
const std::optional<std::string>& shill_error) {
DCHECK(GetNetworkStateHandler());
const NetworkState* network_state =
GetNetworkStateHandler()->GetNetworkStateFromGuid(guid);
if (!network_state)
return;
ShillConnectResult connect_result =
shill_error ? ShillErrorToConnectResult(*shill_error)
: ShillConnectResult::kSuccess;
const bool is_not_repeated_error =
!is_repeated_error || connect_result == ShillConnectResult::kSuccess;
for (const auto& network_type : GetNetworkTypeHistogramNames(network_state)) {
base::UmaHistogramEnumeration(
base::StrCat(
{kNetworkMetricsPrefix, network_type, kAllConnectionResultSuffix}),
connect_result);
if (is_auto_connect) {
base::UmaHistogramEnumeration(
base::StrCat({kNetworkMetricsPrefix, network_type,
kNonUserInitiatedConnectionResultSuffix}),
connect_result);
}
if (is_not_repeated_error) {
base::UmaHistogramEnumeration(
base::StrCat({kNetworkMetricsPrefix, network_type,
kFilteredConnectionResultSuffix}),
connect_result);
}
}
}
// static
void NetworkMetricsHelper::LogUserInitiatedConnectionResult(
const std::string& guid,
const std::optional<std::string>& network_connection_error) {
DCHECK(GetNetworkStateHandler());
const NetworkState* network_state =
GetNetworkStateHandler()->GetNetworkStateFromGuid(guid);
if (!network_state)
return;
UserInitiatedConnectResult connect_result =
network_connection_error
? NetworkConnectionErrorToConnectResult(*network_connection_error,
network_state->GetError())
: UserInitiatedConnectResult::kSuccess;
for (const auto& network_type : GetNetworkTypeHistogramNames(network_state)) {
base::UmaHistogramEnumeration(
base::StrCat({kNetworkMetricsPrefix, network_type,
kUserInitiatedConnectionResultSuffix}),
connect_result);
}
}
// static
void NetworkMetricsHelper::LogConnectionStateResult(
const std::string& guid,
const ConnectionState connection_state,
const std::optional<ShillConnectResult> shill_error) {
DCHECK(GetNetworkStateHandler());
const NetworkState* network_state =
GetNetworkStateHandler()->GetNetworkStateFromGuid(guid);
if (!network_state) {
return;
}
// Only when WiFi network becomes "failure" from a connected state indicates
// there's a real disconnection without user action. If the network becomes
// "idle" from a connected state with a shill error, it usually indicates the
// disconnections are triggered by device suspend. See
// go/cros-wifi-disconnection-metrics for details.
if (network_state->GetNetworkTechnologyType() ==
NetworkState::NetworkTechnologyType::kWiFi &&
connection_state == ConnectionState::kDisconnectedWithoutUserAction &&
network_state->connection_state() != shill::kStateFailure) {
return;
}
for (const auto& network_type : GetNetworkTypeHistogramNames(network_state)) {
base::UmaHistogramEnumeration(kNetworkMetricsPrefix + network_type +
kDisconnectionsWithoutUserActionSuffix,
connection_state);
if (connection_state == ConnectionState::kDisconnectedWithoutUserAction) {
DCHECK(shill_error.has_value());
base::UmaHistogramEnumeration(
kNetworkMetricsPrefix + network_type +
kDisconnectionsWithoutUserActionShillErrorSuffix,
*shill_error);
}
}
}
void NetworkMetricsHelper::LogEnableTechnologyResult(
const std::string& technology,
bool success,
const std::optional<std::string>& shill_error) {
std::optional<const std::string> suffix = GetTechnologyTypeSuffix(technology);
if (!suffix)
return;
if (success == shill_error.has_value()) {
if (shill_error.has_value()) {
NET_LOG(ERROR) << "Error code: " << *shill_error
<< " for successful enable operation on: " << technology;
} else {
NET_LOG(ERROR)
<< "Missing error code for unsuccessful enable operation on: "
<< technology;
}
}
ShillConnectResult result = shill_error
? ShillErrorToConnectResult(*shill_error)
: ShillConnectResult::kSuccess;
base::UmaHistogramEnumeration(
base::StrCat(
{kNetworkMetricsPrefix, *suffix, kEnableTechnologyResultCodeSuffix}),
result);
base::UmaHistogramBoolean(base::StrCat({kNetworkMetricsPrefix, *suffix,
kEnableTechnologyResultSuffix}),
success);
}
// static
void NetworkMetricsHelper::LogDisableTechnologyResult(
const std::string& technology,
bool success,
const std::optional<std::string>& shill_error) {
std::optional<const std::string> suffix = GetTechnologyTypeSuffix(technology);
if (!suffix)
return;
if (success == shill_error.has_value()) {
if (shill_error.has_value()) {
NET_LOG(ERROR) << "Error code: " << *shill_error
<< " for successful disable operation on: " << technology;
} else {
NET_LOG(ERROR)
<< "Missing error code for unsuccessful disable operation on: "
<< technology;
}
}
ShillConnectResult result = shill_error
? ShillErrorToConnectResult(*shill_error)
: ShillConnectResult::kSuccess;
base::UmaHistogramEnumeration(
base::StrCat(
{kNetworkMetricsPrefix, *suffix, kDisableTechnologyResultCodeSuffix}),
result);
base::UmaHistogramBoolean(base::StrCat({kNetworkMetricsPrefix, *suffix,
kDisableTechnologyResultSuffix}),
success);
}
NetworkMetricsHelper::NetworkMetricsHelper() = default;
NetworkMetricsHelper::~NetworkMetricsHelper() = default;
} // namespace ash
Codebase Browser
chromium