Tether: record each type of host connection result.

chromeos/components/tether/tether_connector.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromeos/components/tether/tether_connector.h"
 
 #include "base/bind.h"
 #include "chromeos/components/tether/active_host.h"
 #include "chromeos/components/tether/device_id_tether_network_guid_map.h"
+#include "chromeos/components/tether/host_connection_metrics_logger.h"
 #include "chromeos/components/tether/host_scan_cache.h"
 #include "chromeos/components/tether/notification_presenter.h"
 #include "chromeos/components/tether/tether_host_fetcher.h"
 #include "chromeos/components/tether/wifi_hotspot_connector.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "components/proximity_auth/logging/logging.h"
 
 namespace chromeos {
 
 namespace tether {
 
 TetherConnector::TetherConnector(
     NetworkStateHandler* network_state_handler,
     WifiHotspotConnector* wifi_hotspot_connector,
     ActiveHost* active_host,
     TetherHostFetcher* tether_host_fetcher,
     BleConnectionManager* connection_manager,
     TetherHostResponseRecorder* tether_host_response_recorder,
     DeviceIdTetherNetworkGuidMap* device_id_tether_network_guid_map,
     HostScanCache* host_scan_cache,
-    NotificationPresenter* notification_presenter)
+    NotificationPresenter* notification_presenter,
+    HostConnectionMetricsLogger* host_connection_metrics_logger)
     : network_state_handler_(network_state_handler),
       wifi_hotspot_connector_(wifi_hotspot_connector),
       active_host_(active_host),
       tether_host_fetcher_(tether_host_fetcher),
       connection_manager_(connection_manager),
       tether_host_response_recorder_(tether_host_response_recorder),
       device_id_tether_network_guid_map_(device_id_tether_network_guid_map),
       host_scan_cache_(host_scan_cache),
       notification_presenter_(notification_presenter),
+      host_connection_metrics_logger_(host_connection_metrics_logger),
       weak_ptr_factory_(this) {}
 
 TetherConnector::~TetherConnector() {
   if (connect_tethering_operation_) {
     connect_tethering_operation_->RemoveObserver(this);
   }
 }
 
 void TetherConnector::ConnectToNetwork(
     const std::string& tether_network_guid,
@@ skipping 40 matching lines @@
 
   tether_host_fetcher_->FetchTetherHost(
       device_id_pending_connection_,
       base::Bind(&TetherConnector::OnTetherHostToConnectFetched,
                  weak_ptr_factory_.GetWeakPtr(),
                  device_id_pending_connection_));
 }
 
 bool TetherConnector::CancelConnectionAttempt(
     const std::string& tether_network_guid) {
+  host_connection_metrics_logger_->RecordConnectionToHostResult(

[Kyle Horimoto, 2017/07/07 17:06:33]

Move this down to after the device ID check. This shouldn't be logged if it
doesn't actually correspond to an active attempt.

[Ryan Hansberry, 2017/07/12 16:37:06]

Done.

+      HostConnectionMetricsLogger::ConnectionToHostResult::
+          CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_CANCELED_BY_USER);
+
   const std::string device_id =
       device_id_tether_network_guid_map_->GetDeviceIdForTetherNetworkGuid(
           tether_network_guid);
 
   if (device_id != device_id_pending_connection_) {
     PA_LOG(ERROR) << "CancelConnectionAttempt(): Cancel requested for Tether "
                   << "network with GUID " << tether_network_guid << ", but "
                   << "there was no active connection to that network.";
     return false;
   }
@@ skipping 55 matching lines @@
     PA_LOG(INFO) << "Received failed ConnectTetheringResponse from device with "
                  << "ID " << remote_device.GetTruncatedDeviceIdForLogs()
                  << ", but a connection to another device has already started.";
     return;
   }
 
   PA_LOG(WARNING) << "Connection to device with ID "
                   << remote_device.GetTruncatedDeviceIdForLogs()
                   << " could not complete. Error code: " << error_code;
 
+  if (error_code ==
+      ConnectTetheringResponse_ResponseCode::
+          ConnectTetheringResponse_ResponseCode_PROVISIONING_FAILED) {
+    host_connection_metrics_logger_->RecordConnectionToHostResult(
+        HostConnectionMetricsLogger::ConnectionToHostResult::
+            CONNECTION_RESULT_PROVISIONING_FAILED);
+  } else if (error_code ==
+             ConnectTetheringResponse_ResponseCode::
+                 ConnectTetheringResponse_ResponseCode_TETHERING_TIMEOUT) {
+    const std::string tether_network_guid =
+        device_id_tether_network_guid_map_->GetTetherNetworkGuidForDeviceId(
+            remote_device.GetDeviceId());
+    bool setup_was_required =
+        host_scan_cache_->DoesHostRequireSetup(tether_network_guid);
+    host_connection_metrics_logger_->RecordConnectionToHostResult(
+        setup_was_required
+            ? HostConnectionMetricsLogger::ConnectionToHostResult::
+                  CONNECTION_RESULT_FAILURE_TETHERING_TIMED_OUT_FIRST_TIME_SETUP_WAS_REQUIRED
+            : HostConnectionMetricsLogger::ConnectionToHostResult::
+                  CONNECTION_RESULT_FAILURE_TETHERING_TIMED_OUT_FIRST_TIME_SETUP_WAS_NOT_REQUIRED);
+  } else {
+    host_connection_metrics_logger_->RecordConnectionToHostResult(
+        HostConnectionMetricsLogger::ConnectionToHostResult::
+            CONNECTION_RESULT_FAILURE_UNKNOWN_ERROR);
+  }
+
   connect_tethering_operation_->RemoveObserver(this);
   connect_tethering_operation_.reset();
   SetConnectionFailed(NetworkConnectionHandler::kErrorConnectFailed);
 }
 
 void TetherConnector::OnTetherHostToConnectFetched(
     const std::string& device_id,
     std::unique_ptr<cryptauth::RemoteDevice> tether_host_to_connect) {
   if (device_id_pending_connection_ != device_id) {
     PA_LOG(INFO) << "Device to connect to has changed while device with ID "
                  << cryptauth::RemoteDevice::TruncateDeviceIdForLogs(device_id)
                  << " was being fetched.";
     return;
   }
 
   if (!tether_host_to_connect) {
     PA_LOG(ERROR) << "Could not fetch tether host with device ID "
                   << cryptauth::RemoteDevice::TruncateDeviceIdForLogs(device_id)
                   << ". Cannot connect.";
     SetConnectionFailed(NetworkConnectionHandler::kErrorConnectFailed);
+    host_connection_metrics_logger_->RecordConnectionToHostResult(

[Kyle Horimoto, 2017/07/07 17:06:33]

See comment on other CL - I think this should just be an internal error. Also,
should be moved to SetConnectionFailed().

[Ryan Hansberry, 2017/07/12 16:37:06]

Done.

+        HostConnectionMetricsLogger::ConnectionToHostResult::
+            CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_HOST_FETCH_FAILURE);
     return;
   }
 
   DCHECK(device_id == tether_host_to_connect->GetDeviceId());
 
-  const std::string& tether_network_guid =
+  const std::string tether_network_guid =
       device_id_tether_network_guid_map_->GetTetherNetworkGuidForDeviceId(
           device_id);
   connect_tethering_operation_ =
       ConnectTetheringOperation::Factory::NewInstance(
           *tether_host_to_connect, connection_manager_,
           tether_host_response_recorder_,
           host_scan_cache_->DoesHostRequireSetup(tether_network_guid));
   connect_tethering_operation_->AddObserver(this);
   connect_tethering_operation_->Initialize();
 }
@@ skipping 15 matching lines @@
   active_host_->SetActiveHostDisconnected();
 }
 
 void TetherConnector::SetConnectionSucceeded(
     const std::string& device_id,
     const std::string& wifi_network_guid) {
   DCHECK(!device_id_pending_connection_.empty());
   DCHECK(device_id_pending_connection_ == device_id);
   DCHECK(!success_callback_.is_null());
 
+  host_connection_metrics_logger_->RecordConnectionToHostResult(
+      HostConnectionMetricsLogger::ConnectionToHostResult::
+          CONNECTION_RESULT_SUCCESS);
+
   notification_presenter_->RemoveSetupRequiredNotification();
 
   // Save a copy of the callback before resetting it below.
   base::Closure success_callback = success_callback_;
 
   device_id_pending_connection_.clear();
   success_callback_.Reset();
   error_callback_.Reset();
 
   success_callback.Run();
@@ skipping 18 matching lines @@
     return;
   }
 
   if (wifi_network_guid.empty()) {
     // If the Wi-Fi network ID is empty, then the connection did not succeed.
     PA_LOG(ERROR) << "Failed to connect to the hotspot belonging to the device "
                   << "with ID "
                   << cryptauth::RemoteDevice::TruncateDeviceIdForLogs(device_id)
                   << ".";
 
+    host_connection_metrics_logger_->RecordConnectionToHostResult(

[Kyle Horimoto, 2017/07/07 17:06:33]

Same thing - think you should move to SetConnectionFailed().

[Ryan Hansberry, 2017/07/12 16:37:06]

Done.

+        HostConnectionMetricsLogger::ConnectionToHostResult::
+            CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_TIMEOUT);
+
     SetConnectionFailed(NetworkConnectionHandler::kErrorConnectFailed);
     return;
   }
 
   SetConnectionSucceeded(device_id, wifi_network_guid);
 }
 
 }  // namespace tether
 
 }  // namespace chromeos